# Made by Aris: full article text
> Every blog post by Aris Setiawan, as plain text. The short index is at https://madebyaris.com/llms.txt.
---
## Can a 1 GB VPS serve a million WordPress requests a minute?
URL: https://madebyaris.com/blog/1-million-wordpress-requests-1gb-vps
Published: 2026-11-12. Updated: 2026-11-12.
### Summary
I wanted to know whether one small WordPress server could handle 1,000,000 requests per minute. The server was an UpCloud VPS with one vCPU and 1 GB of RAM, running Nginx, PHP 8.4, MariaDB and Valkey, with the finished HTML pages cached in RAM.
Benchmarks run on the server itself said yes. It answered 1,000,000 HTTPS requests in 55.8 seconds, which works out to about 1,075,000 per minute. Real traffic from Loader.io said yes too, for a small page. The best external run was 1,034,655 requests in one minute with zero errors, an average response of 137 ms and a maximum of 792 ms, with Loader.io ramping from 0 to 5,000 clients. For the full 25 KB homepage, the best clean run was 271,412 requests in one minute.
Most of the gap came from four things: the memory each open HTTPS connection costs, an Nginx setting I had added that made memory use worse, Cloudflare’s DDoS protection blocking the test when I put Cloudflare in front, and the fact that a benchmark on the same machine never touches the network.
### The test server
Item | Value |
Provider and location | UpCloud, Chicago |
CPU | 1 vCPU, AMD EPYC 9575F (KVM) |
RAM | 856 MiB usable (1 GB plan), plus a 2 GB swap file I added |
Disk | 25 GB |
OS and kernel | CentOS Stream 10, Linux 6.12 |
Web server | Nginx 1.26.3 with OpenSSL 3.5 |
PHP | PHP 8.4.27 FPM with OPcache and the tracing JIT |
Database and object cache | MariaDB 10.11, Valkey 8.1 over a Unix socket |
WordPress | WordPress 7.1.4, Ollie 1.6.6 block theme, Redis Object Cache plugin |
The test site was testwp.madebyaris.com: a Gutenberg landing page, four inner pages, three blog posts, and a plain-text page at /lite/ made for low-bandwidth testing.
### How the server was set up
#### Kernel and network
The defaults on a small VPS are sized for light traffic, so I raised the connection queues and file limits and switched TCP to BBR:
```
net.core.somaxconn = 65535
net.ipv4.tcp_max_syn_backlog = 65535
net.core.netdev_max_backlog = 65535
net.core.default_qdisc = fq
net.ipv4.tcp_congestion_control = bbr
net.ipv4.tcp_fastopen = 3
net.ipv4.tcp_tw_reuse = 1
net.ipv4.ip_local_port_range = 1024 65535
net.ipv4.tcp_mem = 32768 49152 65536
net.ipv4.tcp_max_orphans = 65536
fs.file-max = 2097152
vm.swappiness = 10
```
Nginx runs one worker (one CPU) with worker_connections 65535, reuseport, a listen backlog of 65535, and a file limit of 262,144. The kernel TLS module is loaded so Nginx can hand encryption to the kernel. HTTP/2 and HTTP/3 are on.
#### Two layers of page cache in RAM
A 192 MB tmpfs (a RAM disk) holds two caches:
- A small must-use plugin writes every anonymous page view to the RAM disk as index.html, plus a pre-compressed index.html.gz. Nginx serves those files directly with try_files, gzip_static and sendfile, so a cached request never reaches PHP.
- Behind that sits the Nginx FastCGI cache, also on the RAM disk, with fastcgi_cache_lock and fastcgi_cache_use_stale so a burst of misses produces one PHP render instead of hundreds.
Logged-in users, WooCommerce cart cookies, query strings, wp-admin, wp-login.php and the REST API skip both caches. The plugin clears both when a post, menu, comment or theme changes.
#### PHP and one SELinux surprise
PHP-FPM uses OPcache (96 MB) and the tracing JIT (opcache.jit = 1255, 32 MB buffer). With SELinux enforcing, the first page request failed with “502 Bad Gateway”. The PHP workers were crashing with a segmentation fault, because SELinux blocks a web server process from creating executable memory, which the JIT needs. Setting setsebool -P httpd_execmem 1 fixed it while keeping SELinux enforcing. If you enable the JIT on RHEL, CentOS or Fedora and get unexplained 502s, check the audit log for execmem denials.
### Benchmarks on the server itself
These ran on the VPS against its own address, with the load tool sharing the single CPU.
Test | Result |
1,000,000 HTTPS requests, keep-alive, 200 connections, 12 KB gzipped page | 55.8 s, 17,922 requests/s, 0 failed, median 11 ms, 99th percentile 19 ms |
Same, Ollie homepage (25.9 KB gzipped), 200,000 requests | 15,421 requests/s, 0 failed |
/lite/ page (0.7 KB), new connection per request, 200,000 requests | 11,892 requests/s, 0 failed |
Uncached dynamic page (logged-in cookie), 8 at a time | 27 requests/s, median 286 ms |
The first row is the “1 million a minute” number. It is real, but it measures Nginx serving a file from RAM to a client on the same machine. Traffic never crosses the network card, there is no internet latency or packet loss, and every client finishes its connection almost instantly. The external tests below behaved very differently.
The last row is worth keeping in mind too. Without the page cache, this server renders about 27 WordPress pages per second.
### Load tests from Loader.io
Loader.io sends traffic from Amazon servers. Most runs used its “clients per second” mode: a set number of new clients each second for one minute, each making requests over its own connection.
Run | Setup | Successful | Errors | Average response | Data received |
1 | Homepage, 10,000 clients/s, direct to VPS | 716 | 4,752 network | 14,206 ms | 37.5 MB (aborted) |
2 | Homepage, 1,500 clients/s, direct, HTTP | 89,998 | 0 | 28 ms | 2.19 GB |
3 | Homepage, 2,500 clients/s, direct, HTTP | 147,445 | 0 | 29 ms | 3.59 GB |
4 | Homepage, 10,000 clients/s, through Cloudflare, HTTPS | 48,049 | 201,389 HTTP 403 | 1,141 ms | 2.46 GB (aborted) |
5 | /lite/, 10,000 clients/s, direct | 94,086 | 7,018 network | 9,662 ms | 98.6 MB |
6 | /lite/, 10,000 clients/s, direct, after first fixes | 46,114 | 16,686 network | 15,118 ms | 48.3 MB |
7 | /lite/, 5,000 clients/s, direct | 299,799 | 0 | 1,063 ms | 314 MB |
8 | Homepage, ramp from 0 to 2,000 concurrent clients | 271,412 | 0 | 209 ms | 6.61 GB |
9 | 0 to 5,000 clients over 1 minute | 1,034,655 | 0 | 137 ms | 1.06 GB |
Run 9 is the headline number: 1,034,655 requests in one minute with zero errors, an average response of 137 ms and a maximum of 792 ms. The Loader.io result summary does not show which URL it hit, but 1.06 GB over 1,034,655 responses is about 1 KB each, which fits the small /lite/ page rather than the homepage. During the run, htop on the VPS showed 416 MB of 857 MB RAM and 179 MB of swap in use. For the real homepage, run 8 is the best clean result among these runs, at about 270,000 requests per minute with no errors.
Run 7 still had a stall in its first 20 seconds, when response times climbed to about 15 seconds before settling well under one second. The rest of this section is about what broke in the other runs.
#### Run 1: more traffic than the server could hold
10,000 new clients per second at 25 KB each is about 257 MB/s, or roughly 2 Gbps of outgoing traffic. While connections waited, the kernel spent 61 seconds under TCP memory pressure (it had auto-sized its buffer limit to about 68 MB on this 1 GB machine), and the Nginx worker grew to about 1 GB, most of it pushed into swap. Response times climbed to 18 seconds and Loader.io aborted.
At the time I measured outgoing bandwidth with parallel uploads to Cloudflare’s speed test and got about 550 Mbps. Run 8 later averaged 6.61 GB in 60 seconds, about 880 Mbps, so that upload test underestimated what the VPS can send. In either case, 2 Gbps was out of reach.
#### Run 4: Cloudflare blocked the test
With the DNS record switched to proxied and a cache rule for the site, Cloudflare served the homepage from its edge cache, with the fastest responses at 6 ms. Around five seconds in, Cloudflare’s HTTP DDoS protection classified Loader.io as an attack and returned 403 for the rest of the run. Cloudflare’s analytics showed the rule source as l7ddos, and only 6 requests reached the VPS.
The zone already had a WAF custom rule that skips security checks for the loader.io user agent. That rule does not cover the DDoS protection. On the Free plan, the HTTP DDoS ruleset allows one override, and it applies to every request in the zone, so loosening it for a test also loosens it for every other subdomain. I chose not to, and tested directly against the VPS instead.
#### Runs 5 and 6: the Nginx worker ran out of memory
The 0.7 KB /lite/ page should have removed the bandwidth problem. It did, but the server still ran out of memory. After run 6 the Nginx worker held about 840 MB (355 MB in RAM and 480 MB in swap). A once-a-second memory recorder in a later run showed how fast this happens: the worker went from 34 MB to 872 MB within ten seconds of Loader.io starting, and for those seconds Nginx could not answer a local status check within one second. The request log showed Nginx itself was never slow: every one of 387,524 logged Loader.io requests took 0 ms to process. The time went to waiting for memory pages to come back from disk.
I found two causes.
The first was a setting I had added: aio threads with directio. For files that already live in RAM it adds nothing, and it made Nginx allocate extra buffers per request. With 5,000 keep-alive connections, removing it lowered the worker’s peak memory from 63 MB to 35 MB and raised throughput from about 25,000 to 31,000 requests per second.
The second was HTTPS. With the same 5,000 keep-alive connections, the Nginx worker stayed at 35 MB over plain HTTP and reached 315 MB over HTTPS. That is about 56 KB of encryption state per open connection. Loader.io keeps around 20,000 connections open, which needs about 1.1 GB over HTTPS on a machine with 856 MB of RAM. Holding 20,000 idle HTTP keep-alive connections, for comparison, added only 9 MB to the worker. I did not log the protocol of runs 5 and 6, but their memory profile matched the HTTPS reproduction, and the HTTP reproduction never came close.
Before finding the HTTPS cause I also tried two other ideas, a shorter keepalive_timeout (65 down to 15 seconds) and telling glibc to return freed memory sooner. The malloc change made no measurable difference, so I removed it.
#### What Loader.io’s traffic looked like
A temporary access log during run 7 and the run before it showed:
- about 20,000 connections open at the same time, from 5 Amazon IP addresses
- an average of 7.6 requests per connection, a maximum of 498, and no pipelining
- 143-byte requests, all answered with status 200
- up to 11,002 requests per second at Nginx in a single second
#### Connections that never arrived
In run 6, the kernel counted about 45,600 new connections from Loader.io, while Loader.io reported about 62,800 attempts. The kernel’s listen queue never overflowed and the network card dropped no packets, so roughly 17,000 attempts never reached the server’s TCP stack. I could not tell whether they were lost in the provider’s network or never sent because Loader.io’s own client was saturated. The 15-second average response time fits clients retrying lost connection attempts, but this one stays unresolved.
### Making the homepage lighter
Loader.io only downloads the HTML, but a real visitor downloads everything. I measured every file the homepage loads and cut the weight without changing how it looks.
| Before | After |
HTML (gzipped) | 25.1 KB | 15.6 KB |
HTML plus every CSS, font and image file | 852 KB | 287 KB |
Images loaded before scrolling | 19 | 1 |
Font file (Mona Sans) | 164 KB | 47 KB |
JavaScript | 20 KB | none |
What changed:
- Each image was resized to the size it is displayed at. The theme’s six avatar images were 1001 × 1000 px and display at 60 to 76 px; at 160 × 160 they went from 330 KB to 20 KB in total. The photo behind the stats banner sits under a 90% colour overlay, so it took heavier compression (38 KB to 17 KB).
- Only the hero image loads immediately. The other 18 images get loading="lazy", and blog card images get a sizes hint so desktops pick the 768 px version instead of the full one.
- Mona Sans is a variable font with weight and width axes. No page used the condensed or expanded widths, so I fixed the width at 100% with fonttools varLib.instancer and subset it to Latin characters with pyftsubset, keeping weights 200 to 900.
- WordPress inlined about 40 KB of block CSS into every page. Setting the styles_inline_size_limit filter to 0 moved it into separate, cacheable CSS files. A first visit makes about 30 small extra CSS requests, which HTTP/2 handles well.
- The emoji detection script went away, and so did the mobile hamburger menu, which loaded 42 KB of the Interactivity API. With five links, a menu that wraps onto a second line looks fine on a phone and needs no JavaScript.
Two of these edits change files inside the Ollie theme (images and the font), so a theme update would bring the heavy versions back. A child theme is the better long-term home for them.
### Conclusions
On this 1 vCPU, 1 GB VPS, an external Loader.io run reached 1,034,655 requests in one minute with zero errors for a small page (about 1 KB per response). For a real 25 KB homepage, the best clean external result among the runs in this post was 271,412 requests in one minute. So the answer to the title is yes, at least for a small cached page.
What limited this machine, in the order I ran into it:
- Outgoing bandwidth, for the full homepage at 10,000 new clients per second.
- RAM per open connection, especially over HTTPS at about 56 KB each. With 856 MB of RAM, a few thousand concurrent HTTPS clients are safe and 20,000 are not.
- My own aio threads setting, which made the memory problem worse and lowered throughput for files served from RAM.
- Cloudflare’s DDoS protection, which blocks a load test that looks like an attack and cannot be loosened for one subdomain on the Free plan.
To push the full homepage further on a machine this size, I would put a CDN’s edge cache in front, on a plan where DDoS sensitivity can be adjusted for test traffic, or give the origin more RAM and CPU if it must terminate HTTPS itself. I would also always run load tests from outside the server and check RAM, swap and the Nginx status page during the run, because a benchmark on the server itself hides exactly the problems that showed up here.
### Appendix: the Nginx pieces that mattered
```
worker_processes auto;
worker_rlimit_nofile 262144;
events {
worker_connections 65535;
use epoll;
multi_accept on;
}
http {
sendfile on;
tcp_nopush on;
tcp_nodelay on;
keepalive_timeout 15;
open_file_cache max=50000 inactive=60s;
open_file_cache_valid 30s;
gzip_static on;
ssl_conf_command Options KTLS;
fastcgi_cache_path /var/cache/wp-ram/fastcgi levels=1:2 keys_zone=WORDPRESS:32m
max_size=96m inactive=60m use_temp_path=off;
server {
listen 80 reuseport backlog=65535;
listen 443 ssl reuseport backlog=65535;
http2 on;
location / {
try_files $static_cache_root$cache_uri/index.html $uri $uri/ /index.php?$args;
}
}
}
```
$static_cache_root comes from a map that points to the RAM-disk cache only for anonymous GET requests without a query string, and to a path that never exists otherwise, so those requests fall through to PHP.
---
## Fastify vs Express: mana yang dipilih untuk API Node.js baru
URL: https://madebyaris.com/blog/fastify-vs-express-untuk-api-baru
Published: 2026-11-08. Updated: 2026-11-08.
Untuk API Node.js baru, pilih Fastify kalau kamu ingin input tervalidasi, logging bawaan, dan struktur yang jelas saat API tumbuh. Pilih Express kalau API-nya kecil, tim kamu sudah menguasainya, atau kamu bergantung pada middleware yang hanya ada untuk Express. Keduanya layak dipakai, dan pilihan di antara keduanya tidak sepenting yang sering ditulis.
### Perbedaan yang benar-benar terasa
Perbandingan ini mengacu pada Fastify 5 dan Express 5, versi mayor saat ini.
| Fastify | Express |
Validasi input | Bawaan. Kamu mendeskripsikan request dengan JSON Schema dan Fastify memvalidasinya sebelum handler jalan. | Tidak termasuk. Kamu menambah library seperti Zod, Joi, atau express-validator dan menyambungkannya sendiri. |
Logging | Pino sudah bawaan, log terstruktur tinggal diaktifkan. | Tidak termasuk. Kamu menambah morgan atau pino-http. |
Struktur | Plugin dengan enkapsulasi. Satu plugin bisa menambah route, hook, dan decorator tanpa bocor ke bagian lain aplikasi. | Rantai middleware dan router. Sederhana, tetapi gampang berubah jadi kusut. |
Handler async | Handler async berjalan secara native. | Express 5 meneruskan promise yang ditolak dari handler async ke error handler. |
TypeScript | Tipe sudah ada di dalam paket. | Tipe datang dari paket terpisah, @types/express. |
Ekosistem | Plugin banyak, usianya lebih muda. | Ekosistem terbesar di Node.js, dengan contoh dan jawaban paling banyak. |
### Benchmark kecil dari saya
Saya menulis dua route yang sama di kedua framework dan mengujinya dengan autocannon: GET yang mengembalikan objek JSON kecil, dan POST yang memvalidasi body berisi dua field. Fastify memakai JSON Schema. Express memakai pengecekan yang ditulis manual.
Route | Fastify 5.12.8 | Express 5.3.0 |
GET /json | sekitar 101.000 request per detik | sekitar 40.000 request per detik |
POST /echo dengan validasi | sekitar 68.000 request per detik | sekitar 35.000 request per detik |
Angka ini adalah median dari tiga kali uji 8 detik dengan 100 koneksi, di Apple M4 dengan Node.js 26.13.0, sementara aplikasi lain terbuka di mesin yang sama. Uji pertama memberi angka absolut yang berbeda, jadi baca hasilnya sebagai “Fastify melayani sekitar 1,5 sampai 2,5 kali lebih banyak request per detik pada route ini”, tanpa terlalu serius pada angka persisnya.
Benchmark hello-world hanya sedikit bercerita tentang API kamu. Di aplikasi nyata, database dan panggilan ke layanan lain biasanya memakan waktu jauh lebih lama daripada framework. Pilih berdasarkan struktur dan kecocokan dengan tim dulu, dan ukur route kamu sendiri sebelum memutuskan bahwa kecepatan adalah alasan pindah.
### Kapan saya memilih Express
- API kecil dan akan tetap kecil.
- Tim sudah menguasai Express dan merilis dengannya tiap minggu.
- Kamu bergantung pada middleware atau library yang hanya mendukung Express.
- Kamu butuh paling banyak tutorial dan jawaban untuk anggota tim baru.
### Kapan saya memilih Fastify
- Kamu ingin validasi request menjadi bagian dari framework.
- Kamu ingin log terstruktur sejak hari pertama.
- API akan tumbuh, dan kamu ingin plugin memisahkan route dari logika bersama.
- Throughput dan latensi penting, misalnya API di belakang front end yang sibuk.
### Pindah dari Express ke Fastify tanpa menulis ulang
Kamu tidak perlu berhenti dan menulis ulang semuanya. Jalur yang aman adalah memindahkan satu route sekali waktu sambil menjaga test tetap lulus. Fastify punya plugin resmi, @fastify/express, yang membuat middleware Express bisa berjalan di dalam aplikasi Fastify, dan itu membantu selama masa pindah. Mulai dari route yang lambat atau validasinya lemah, karena di situ manfaatnya paling besar.
### Pilihan x.com
X membangun ulang web app-nya di atas React, Vite, Fastify, dan TypeScript, menurut laporan teknik X yang diberitakan iTechPost pada 5 November 2026. Pilihan satu perusahaan besar tidak menentukan apa yang tepat untuk API kamu, tetapi ini menunjukkan Fastify tahan di skala yang sangat besar.
### Langkah berikutnya
Kalau kamu ingin API baru di atas Fastify, atau aplikasi Express dipindahkan, lihat jasa Fastify. Kalau API sudah cepat tetapi database di belakangnya lambat, lihat jasa optimasi database. Versi bahasa Inggris tulisan ini ada di Fastify vs Express. Atau kirim API kamu lewat halaman kontak. Saya balas dalam 24 jam.
---
## Clean code adalah: arti, contoh, dan cara menerapkannya di tim dan AI agent
URL: https://madebyaris.com/blog/apa-itu-clean-code
Published: 2026-11-08. Updated: 2026-11-08.
Clean code adalah kode yang mudah dibaca dan mudah diubah tanpa efek samping yang mengejutkan. Namanya jelas, strukturnya bisa ditebak, dan developer lain bisa memahami cara kerjanya tanpa membongkar logika yang berbelit.
### Tanda kode yang berantakan
- Fungsi yang panjangnya puluhan baris dan mengerjakan beberapa hal sekaligus.
- Nama variabel seperti data, temp, atau flag yang menyembunyikan maksudnya.
- Kondisi bersarang dalam yang memaksa pembaca melacak banyak cabang.
- Logika yang disalin ke banyak tempat, bukan dipakai bersama.
- File yang bergantung erat pada struktur data di lapisan lain.
### Praktik yang paling berpengaruh
Kamu tidak perlu menulis ulang seluruh arsitektur. Beberapa kebiasaan yang konsisten sudah memperbaiki kode di pull request harian.
- Fungsi kecil dan fokus. Satu fungsi mengerjakan satu hal. Kalau sebuah fungsi membaca input, mengecek izin, menulis ke database, dan menyusun email, pecah menjadi beberapa fungsi.
- Nama yang menjelaskan maksud. Kalau sebuah variabel butuh komentar di sebelahnya, ganti namanya.
- Struktur folder per fitur. File yang berkaitan diletakkan berdekatan, sehingga mencari dan mengubah kode lebih cepat.
- Test dan lint. Pengecekan otomatis menangkap kesalahan sebelum review.
### Contoh sebelum dan sesudah
Fungsi berikut menghitung diskon pesanan. Versi pertama sulit dibaca.
```
function calc(d: any) {
if (d.s === 'active') {
if (d.t > 100) {
return d.t * 0.9;
}
}
return d.t;
}
```
Singkatan menyembunyikan maksud, dan kondisi bersarang menambah beban pikiran. Versi yang dirapikan:
```
interface Order {
status: 'active' | 'inactive';
totalAmount: number;
}
const MINIMUM_DISCOUNT_THRESHOLD = 100;
const DISCOUNT_RATE = 0.1;
function calculateDiscountedTotal(order: Order): number {
const isEligible =
order.status === 'active' && order.totalAmount > MINIMUM_DISCOUNT_THRESHOLD;
if (!isEligible) {
return order.totalAmount;
}
return order.totalAmount * (1 - DISCOUNT_RATE);
}
```
Nama, tipe, dan konstanta yang jelas membuat aturan bisnisnya terbaca sekilas.
### Clean code untuk AI agent seperti Cursor
Alat coding AI memprediksi kode berdasarkan konteks di sekitarnya. Di repo dengan penamaan konsisten, tipe yang jelas, dan folder yang rapi, agent menghasilkan kode yang lebih tepat. Di repo yang penuh kode mati dan pola yang bertentangan, agent meniru kekacauan itu.
- Tulis konvensi di AGENTS.md dan aturan proyek, misalnya pola komponen yang dipakai dan library yang tidak boleh dipakai lagi. Lihat juga aturan proyek untuk Cursor (bahasa Inggris).
- Pasang lint, tipe, dan test sebagai pagar pengaman, baik kodenya ditulis orang maupun agent.
- Pakai checklist review untuk kode hasil AI (bahasa Inggris) sebelum menggabungkan pull request.
### Kesalahan yang sering terjadi
- Mengejar kesempurnaan dan merapikan semua kode lama sebelum merilis fitur, sampai rilis tertunda.
- Terlalu banyak abstraksi, misalnya memecah operasi tiga baris menjadi beberapa pola desain.
- Menganggap satu baris yang padat sebagai kode yang bersih. Kode lebih sering dibaca daripada ditulis, jadi keterbacaan lebih penting.
### Pertanyaan yang sering muncul
Apakah clean code memperlambat pengiriman fitur? Di sprint pertama, menulis test dan memperbaiki nama memang butuh sedikit waktu lebih. Setelah beberapa minggu, tim menghabiskan lebih sedikit waktu mengejar bug dan mengurai efek samping.
Perlukah menulis ulang sistem lama dari nol? Penulisan ulang total jarang berhasil karena membuang penanganan kasus khusus yang sudah dikumpulkan bertahun-tahun. Lebih aman merapikan bertahap: terapkan konvensi di area yang aktif dikerjakan, isolasi modul lama di balik antarmuka yang jelas, dan tambahkan test sebelum mengubah logikanya.
Apa satu aturan terbaik untuk sehari-hari? Tinggalkan kode lebih bersih daripada saat kamu menemukannya. Setiap kali menyentuh sebuah file, perbaiki satu hal kecil.
### Langkah berikutnya
Kalau codebase kamu sudah penuh pola campur aduk dari penulisan cepat atau alat AI, lihat jasa clean code untuk tim dan AI agent. Untuk perbaikan yang terfokus, lihat juga memperbaiki kode hasil AI (bahasa Inggris). Atau kirim repo kamu lewat halaman kontak. Saya balas dalam 24 jam.
---
## Vite adalah: apa itu Vite dan kapan kamu perlu memakainya
URL: https://madebyaris.com/blog/apa-itu-vite
Published: 2026-11-08. Updated: 2026-11-08.
Vite adalah build tool dan dev server untuk aplikasi web modern. Saat kamu menjalankan aplikasi di mode pengembangan, Vite menyajikan file lewat ES modules bawaan browser, jadi server menyala cepat dan perubahan kode muncul hampir seketika. Untuk produksi, Vite membundel kode menjadi file yang siap di-deploy.
### Apa bedanya Vite dengan Create React App dan Webpack
Create React App dan setup Webpack lama membundel seluruh aplikasi sebelum dev server bisa dipakai, jadi waktu tunggu naik seiring aplikasi membesar. Vite melewati langkah itu saat pengembangan. Selain itu, tim React sudah menyatakan Create React App deprecated, sehingga proyek baru jarang punya alasan memakainya.
| Create React App / Webpack lama | Vite |
Dev server | Membundel dulu, makin lambat saat aplikasi besar | Menyajikan ES modules, menyala cepat |
Konfigurasi | Tersembunyi atau perlu eject | File vite.config yang ringkas |
Status | Create React App sudah deprecated | Aktif dikembangkan |
Test | Biasanya Jest | Vitest cocok dipakai di sebelahnya |
### Kapan Vite cocok, dan kapan Next.js lebih cocok
- Pilih Vite untuk aplikasi di balik login, dashboard, dan alat internal yang tidak bergantung pada trafik dari Google.
- Pilih Next.js untuk situs yang butuh server rendering, SEO kuat, dan halaman yang harus terbaca mesin pencari.
- Keduanya bisa dipakai di perusahaan yang sama, masing-masing untuk kebutuhannya.
### Langkah umum pindah dari Create React App ke Vite
- Pasang vite dan @vitejs/plugin-react, lalu buat vite.config.
- Pindahkan index.html ke root proyek dan tambahkan tag script bertipe module yang menunjuk ke file entry.
- Ganti environment variable berawalan REACT_APP_ menjadi VITE_, dan baca lewat import.meta.env.
- Perbarui script start dan build di package.json.
- Jalankan test. Kalau memakai Jest, kamu bisa tetap memakainya atau pindah ke Vitest.
- Bandingkan hasil build dengan versi lama sebelum rilis.
Hal yang paling sering perlu perhatian adalah environment variable, import file non-JavaScript, dan langkah build khusus. Lakukan migrasi di branch terpisah supaya aplikasi yang sedang live tidak terganggu.
### Siapa yang memakai Vite
Web app baru x.com dilaporkan dibangun di atas React, Vite, Fastify, dan TypeScript, menurut laporan teknik X yang diberitakan iTechPost pada 5 November 2026. Satu perusahaan besar memilih sebuah alat tidak otomatis berarti cocok untuk proyek kamu, tetapi ini menunjukkan Vite dipakai di aplikasi berskala sangat besar.
### Langkah berikutnya
Kalau build kamu lambat atau setup lamanya tidak ada yang berani sentuh, lihat jasa migrasi dan pengembangan Vite. Kalau masalahnya ada di aplikasi React yang lambat, lihat jasa optimasi React. Atau kirim aplikasinya lewat halaman kontak. Saya balas dalam 24 jam.
---
## Fastify vs Express: which one for a new Node.js API
URL: https://madebyaris.com/blog/fastify-vs-express
Published: 2026-11-08. Updated: 2026-11-10.
For a new Node.js API, pick Fastify if you want validated input, built-in logging, and a clear structure as the API grows. Pick Express if the API is small, your team already knows it, or you depend on middleware that only exists for Express. Both are fine. The choice matters less than most comparison posts claim.
### What actually differs
Here are the differences that change how you write and run an API. I checked these against Fastify 5 and Express 5, the current major versions.
| Fastify | Express |
Input validation | Built in. You describe the request with JSON Schema and Fastify validates it before your handler runs. | Not included. You add a library such as Zod, Joi, or express-validator and wire it in yourself. |
Logging | Pino is built in and structured logs are one option away. | Not included. You add morgan or pino-http. |
Structure | Plugins with encapsulation. A plugin can add routes, hooks, and decorators without leaking into the rest of the app. | A chain of middleware and routers. Simple, and easy to let grow into a tangle. |
Async handlers | Async handlers work natively. | Express 5 passes a rejected promise from an async handler to your error handler. |
TypeScript | Types ship with the package. | Types come from the separate @types/express package. |
Ecosystem | Large plugin ecosystem, younger. | Largest ecosystem in Node.js, and the most examples and answers online. |
### A small benchmark I ran
I wrote the same two routes in both frameworks and load-tested them with autocannon: a GET that returns a small JSON object, and a POST that validates a body with two fields. Fastify used a JSON Schema. Express used a hand-written check.
Route | Fastify 5.12.8 | Express 5.3.0 |
GET /json | about 101,000 requests per second | about 40,000 requests per second |
POST /echo with validation | about 68,000 requests per second | about 35,000 requests per second |
These are the median of three 8-second runs at 100 connections, on an Apple M4 with Node.js 26.13.0, with other apps open on the same machine. A first trial gave different absolute numbers, so read the result as “Fastify served roughly 1.5 to 2.5 times more requests per second on these routes”, without taking the exact figures too seriously.
A hello-world benchmark tells you little about your own API. In a real app, the database and external calls usually take far more time than the framework does. Pick on structure and team fit first, and measure your own routes before you decide that speed is the reason to switch.
### When I would pick Express
- The API is small and will stay small.
- Your team already knows Express well and ships with it every week.
- You rely on a middleware or library that only supports Express.
- You need the widest choice of tutorials and answers for new team members.
### When I would pick Fastify
- You want request validation to be part of the framework.
- You want structured logs from day one.
- The API will grow, and you want plugins to keep routes and shared logic separate.
- Throughput and latency matter, for example an API that sits behind a busy front end.
### Moving from Express to Fastify without a rewrite
You do not need to stop and rewrite. A safe path is to move one route at a time and keep the tests passing. Fastify has an official plugin, @fastify/express, that lets Express middleware run inside a Fastify app, which helps while you move. Start with the routes that are slow or poorly validated, since those gain the most.
### What x.com chose
X rebuilt its web app on React, Vite, Fastify, and TypeScript, according to its engineering report as covered by iTechPost on 5 November 2026. One large company picking a tool does not decide what is right for your API, but it shows that Fastify holds up at a very large scale.
### Next steps
If you want a new API built on Fastify, or an Express app moved over, see my Fastify development service. If the API is fast and the database behind it is not, see database optimization. Or send me the API through the contact page. I reply within 24 hours.
---
## How I improved RankMySEO sign-in performance
URL: https://madebyaris.com/blog/how-we-made-a-dashboard-fast-on-slow-networks
Published: 2026-11-06. Updated: 2026-11-06.
RankMySEO is a rank tracker I build and run. Many of its users open the dashboard on a phone, on a mobile network in Indonesia that is often busy. In a lab test I measured what that feels like, fixed what was slow, and measured again.
On Chrome Slow 4G with an empty cache, sign-in first contentful paint (FCP) fell from 7.4 seconds to 1.6 seconds. The page downloads 295 KB instead of 1,368 KB. This post covers the method, each change, the restructure that came first, and one change I decided against.
These figures are a lab before-and-after on one setup. They are not a real-world guarantee.
### The setup
The stack is a React single-page app built with Vite, served from Cloudflare Workers static assets. The API is a separate Node service. The marketing site is prerendered HTML that hydrates later.
I measured production builds served with compression, under these conditions:
- Network: Slow 4G through the DevTools Protocol: 150 ms latency, 1.6 Mbps down, 750 Kbps up.
- Cache: disabled.
- Metrics: first contentful paint, largest contentful paint, JavaScript transferred, and total bytes, read from the Performance API after load.
I alternated runs between the old and new builds on the same machine and connection. One lesson from that: run the measurements one at a time. When I fired navigations in parallel, they raced each other and produced numbers that meant nothing.
### What the baseline showed
Build | First paint (FCP) | JavaScript | Total |
Customer app sign-in | 7.4 s | 926 KB | 1,368 KB |
Admin sign-in | 2.8 s | 171 KB | 420 KB |
Marketing home | 2.2 s | 0 KB before paint | 108 KB |
The marketing site was already fine. It ships prerendered HTML and adds its script after the first frame. The customer app was the problem. Every route was a static import in App.tsx. The sign-in page shipped all of the app code: a single 3.2 MB entry chunk.
### The changes
#### Load each route when it opens
I turned every page import into React.lazy, including the app shell and the site layout. The sign-in page no longer pulls either of them. The interesting part is where the Suspense boundaries go. A single boundary at the root would blank the whole screen on every navigation. Instead, each layout wraps its own :
```
export function RouteSuspense({ children }: { children: ReactNode }) {
return (
}>
{children}
)
}
```
The shell, the site layout, and the section layouts each render . When you change screens, the navigation and the site switcher stay put, and only the content area waits. The entry chunk went from 3.2 MB to 373 KB, or 117 KB compressed.
Lazy routes bring one new failure: a tab opened before a deploy asks for chunk names that no longer exist. Vite fires vite:preloadError when that happens. I reload once, guarded by sessionStorage, so a down network cannot cause a reload loop.
#### Defer what is only decoration
A source-map breakdown of the remaining entry showed the animation library at about 450 KB of source. A decorative grid behind the sign-in form pulled it in. I lazy-loaded that component with an empty fallback, so the form paints first.
#### Shrink images to their display size
The logo was a 512 px PNG, 205 KB, shown at 32 px. A 96 px WebP is 948 bytes and looks identical. The sign-in photo got a WebP srcSet (20 KB at 640 px, 47 KB at 1200 px) with fetchPriority="low". It does not compete with code and CSS for bandwidth.
#### Share identical in-flight requests
On load, the shell and the home page both asked for the account and the site list together. I changed the fetch helper so plain GETs for the same path share one in-flight promise. Each caller gets its own structuredClone of the result. Nothing is cached after the request settles, so no data goes stale, and writes are never shared. A unit test asserts both behaviours.
#### Cache hashed files for a year
Production was sending Cache-Control: public, max-age=0, must-revalidate for hashed build files. Every repeat visit revalidated each file, at one round trip each. On Slow 4G, that is at least 150 ms per file. One rule in each Worker _headers file fixed it:
```
/assets/*
Cache-Control: public, max-age=31536000, immutable
```
Before shipping it, I confirmed that every file under /assets/ has a content hash in its name.
#### Start the bot check with the page
Sign-in uses Cloudflare Turnstile. Its script was requested only after the React form mounted, about 6.0 seconds into the slow test. The app Content Security Policy blocks inline scripts. I added a tiny same-origin loader that starts the Turnstile download on /login and /signup only. Now it starts at 0.3 seconds, and the challenge is running while the form is still loading.
### Results
Page | Metric | Before | After | Total before | After |
Customer sign-in | First paint (FCP) | 7.4 s | 1.6 s | 1,368 KB | 295 KB |
Customer sign-in | Largest contentful paint (main image) | 8.5 s | 3.7 s | | |
Admin sign-in | First paint (FCP) | 2.8 s | 1.5 s | 420 KB | 228 KB |
Again: lab before-and-after on one setup, not a real-world guarantee.
### The restructure that came first
None of this would have been a one-day job a week earlier. Before the speed work, I reorganized the codebase:
- Folders by domain. The API and shared packages moved into domain folders. The dashboard 164 screen files moved into one folder per navigation area. File names did not change, so search still finds everything.
- One source per rule. Plan limits, prices, and paid-plan lists were hand-copied across the API, the dashboard, the admin, and the marketing site. They now read from one shared table. That change surfaced a public comparison page listing a plan with 10 keywords instead of 20.
- Fewer, clearer dependencies. Both packages now have zero import cycles, and the platform layer no longer imports from auth.
- Less code. About 6,400 lines removed and 4,200 written, including tests that only restated a table.
That is what made the lazy-route change mechanical. Every page already had an obvious module to point React.lazy at.
### The upgrade gotcha CI caught
I also moved the marketing site from Vite 6 to Vite 8. Its client build dropped from 3.4 seconds to 0.3. CI then failed on its “bundle contains localhost” check. This code:
```
const env = import.meta.env;
export const appOrigin = env.VITE_APP_ORIGIN ?? "http://localhost:5174";
```
worked in Vite 6, where the minifier folded the fallback away. In Vite 8 the aliased import.meta.env became a whole inlined object, and the fallback string stayed in the bundle. The runtime value was still the production origin, but the gate was right to fail. Reading import.meta.env.VITE_APP_ORIGIN directly lets the build replace it, and the fallback drops out.
### Why I did not adopt GraphQL
The marketing pages already stream HTML with early data. For the dashboard, the changes above covered the rest. A second API would also have been costly. The REST API has 256 routes and serves customer API keys, MCP clients, and a phone app. Every GraphQL field would need the same plan limits and cost caps as its REST route. A client-side query cache over the existing REST calls is the next step. It gives the part of a client cache I would actually use. The last answer shows at once while it refreshes.
### Takeaways
- Measure on a throttled connection, with an empty cache, against production builds. Office Wi-Fi hides all of this.
- Put a Suspense boundary at each layout outlet, not only at the root.
- Check your cache headers in production. Hashed files that revalidate on every visit cost a round trip each.
- Look for decoration in the entry chunk with a source map. Mine was 450 KB of animation code on a login page.
- Keep a CI check for the mistakes you have made before. Mine caught a build-tool change on the first try.
---
## What Is PHP? A Plain Introduction for Website Owners
URL: https://madebyaris.com/blog/what-is-php
Published: 2026-10-27. Updated: 2026-10-27.
Your developer says the site “runs on PHP”, your hosting panel has a PHP version dropdown, and a search for “what is PHP” mixes in pages about the Philippine peso. So what is PHP, in plain words, and should you care which version you run?
This post is about PHP the programming language. I will keep it practical: what it is, how it turns code into a page, what a PHP file looks like, and how you can run one on your own laptop in a few commands.
### What is PHP, exactly?
PHP is a recursive acronym for “PHP: Hypertext Preprocessor”, which is the kind of name only programmers find funny. The PHP manual uses that name.
Rasmus Lerdorf created PHP in 1994. In June 1995 he released the source code of “PHP Tools” to the public. The original name was “Personal Home Page Tools”. The PHP history page has the full story.
PHP is open source. Current PHP uses the Modified BSD License (PHP License v4), and older releases used PHP License versions 2.01 to 3.01. The PHP license page has the text.
Two groups have a formal role. The PHP Group holds the copyright and publishes the license. The PHP Foundation funds and guides core developers. A wider community of contributors does core work as well.
### How does PHP turn code into a page?
A browser asks a server for a page. The server runs the PHP code for that page, PHP builds the response, usually HTML, and the server sends that HTML back. The browser never sees the PHP code. It only sees the result, which is why “view source” on a PHP site shows HTML and nothing else.
PHP can run in more than one way, and two names come up often:
- CLI. The PHP manual says the CLI “is for developing shell applications”. You run a PHP script from a terminal, with no browser involved.
- PHP-FPM. The manual calls FPM (FastCGI Process Manager) a primary PHP FastCGI implementation, meant for sites with heavy load. When your host talks about PHP-FPM, this is the part that serves your web pages.
A CLI command is the easiest one to try:
```
php -r "echo 2 + 2, PHP_EOL;"
```
### What is PHP used for?
#### Websites and WordPress
WordPress runs on PHP. The WordPress requirements recommend PHP 8.3 or later. The same page says WordPress also works with PHP 7.4+, which has reached end of life. So if your site is on WordPress, you already depend on PHP, whether you have opened a PHP file or not.
#### Web apps
A PHP app can handle logins, forms, carts and admin screens. That is the everyday work behind many business sites: take input, check it, store it, show a page.
#### APIs
PHP can also serve JSON to a separate front end, such as a Next.js site. For that setup, read PHP API development for Next.js.
### What does a PHP file look like?
A PHP file ends in .php, and the PHP code starts with the Hello, " . htmlspecialchars($name) . ".
";
echo "
Today is " . date("j M Y") . ".
";
```
The server runs this file and sends two paragraphs of HTML to the browser. The htmlspecialchars call is a small habit worth having from day one, because it escapes text before it goes into HTML.
### What is Composer?
Composer is a tool for dependency management in PHP. You declare the libraries your project needs, and Composer installs and updates them. It is not a system package manager, so it does not install PHP itself.
```
composer init
composer install
```
### Is PHP still used, and is it safe?
Yes, it is still used. PHP is on 69.2% of websites with a known server-side language, per W3Techs on 27 Oct 2026.
Safety depends on the version and the code. PHP apps need updates and safe code.
### How do I start with PHP?
- Install PHP. The PHP install guide has pages for Linux packages, macOS and Windows.
- Check the version with php -v. On 27 Oct 2026, php.net lists 8.5.12 as the latest stable release.
- Make a folder with an index.php file, like the sample above.
- Run the built-in web server in that folder.
- Open localhost:8000 in your browser.
```
mkdir hello-php && cd hello-php
php -v
php -S localhost:8000
```
The built-in server is for development only. The PHP manual says not to use it on a public network, so keep it on your laptop.
### How long have I worked with PHP?
I have worked with PHP and WordPress since 2013, when I started as a full-stack PHP developer one week after vocational school. Now I also build with JavaScript and Go, but clients still ask me for PHP apps, and I still trust PHP.
### When does PHP fit your project?
If your site runs on WordPress, you already use PHP. Learn enough to read a theme file and to know which PHP version your host runs.
If you need a content site with an admin area, PHP and WordPress can do that job.
If you need a custom web app or an API, PHP can do the job too. Pick it when your team or your developer knows it well, because that matters more to me than the language chart.
If your front end is Next.js, PHP can still serve the data. Read tentang Next.js dan PHP (Indonesian).
### Verdict
PHP is a server-side language that turns code into HTML, it runs WordPress, and it is easy to try on your own machine with php -S. For a website owner, the two things worth knowing are that it exists under your site and that its version needs updates. If you want a PHP app built or fixed, this is how I work on PHP development.
---
## Is PHP Dead? PHP and WordPress Now, and What Is Set for 2027
URL: https://madebyaris.com/blog/future-of-php-and-wordpress-2027
Published: 2026-10-27. Updated: 2026-10-27.
You run a business on a PHP app or a WordPress site. Someone at a meetup, or in a comment thread, told you PHP is dead and you should rebuild everything in JavaScript before it is too late. Is that true, and is it still safe to keep building on PHP?
Short answer: no, PHP is not dead. The usage numbers below are large, and the release calendar says it is still moving. The more useful question is whether your own app is on a version that still gets fixes.
### What do the numbers say?
All W3Techs figures here are from 27 Oct 2026. PHP is on 69.2% of websites with a known server-side language. Of those PHP sites, 65.6% run version 8, 26.6% run version 7, and 7.7% run version 5. WordPress runs 39.6% of all websites, and 58.3% of sites with a known CMS.
Developers still use it, too. The Stack Overflow Developer Survey 2025 asked about extensive development work in the past year, and PHP got 18.9% of all respondents. That is a lot of people for a dead language.
For WordPress sites, the wordpress.org stats API gives the PHP version split. You can read the raw data yourself:
```
curl -s https://api.wordpress.org/stats/php/1.0/
```
On 27 Oct 2026 it returned these shares:
PHP version |
Share of WordPress sites |
8.3 |
27.355% |
8.2 |
23.161% |
7.4 |
15.076% |
8.4 |
10.179% |
8.1 |
9.588% |
8.5 |
5.647% |
8.0 |
3.508% |
Add up 8.1, 8.0, 7.4 and the older lines, and you get about 34% of WordPress sites on PHP versions with no project support. That figure is the total of the API values for those versions. So PHP is alive, and a large share of it runs old.
### What changed in PHP, and what is next?
The current release is PHP 8.5.12. PHP 8.5.0 came out on 20 Nov 2025. PHP 8.6 is next: RC4 came out on 21 Oct 2026, the PHP project plans RC5 for 5 Nov, and it targets general availability on 19 Nov 2026. That plan can change, as release plans do.
Each version gets active support, then security fixes only. This is the php.net table on 27 Oct 2026:
Version |
Active support until |
Security fixes until |
8.2 |
ended |
31 Dec 2026 |
8.3 |
ended |
31 Dec 2027 |
8.4 |
31 Dec 2026 |
31 Dec 2028 |
8.5 |
31 Dec 2027 |
31 Dec 2029 |
PHP 8.2 loses security fixes at the end of 2026. On the API numbers above, that is the second largest group of WordPress sites, so a lot of upgrades are due in the next two months.
Support windows matter in practice. On 21 Oct 2026, the PHP project fixed two remote code execution flaws in PHP itself. The fixes shipped for 8.5, 8.4, 8.3 and 8.2. PHP 8.1 and older got no project updates, except minimal source backports for 7.4, 8.0 and 8.1.
To see where your own app stands, this is the check I would run first:
```
php -v
```
### What has WordPress published so far?
WordPress shipped 7.0 on 20 May 2026 and 7.1 on 19 Aug 2026. The latest release is 7.1.3, from 6 Oct. WordPress 7.2 Beta 1 came out on 20 Oct, and the planned release date for 7.2 is 8 Dec 2026.
The roadmap set a goal of three major releases in 2026. Phase 3 of Gutenberg is underway, and it is about collaborative editing.
WordPress has published no release dates for 2027. A roadmap survey is open until 16 Nov 2026. So anyone who gives you a WordPress 2027 calendar today is guessing, including me below.
WordPress recommends PHP 8.3 or later. On the API numbers above, 8.3, 8.4 and 8.5 together cover about 43% of WordPress sites, as a total of the API values.
### Where do PHP and WordPress fall short?
A PHP monolith and a classic WordPress theme tie content and front end together. That is fine until the front end needs to do something the theme was never built for. A JavaScript front end such as Next.js can split the two, with WordPress kept as the place editors write. For that trade, read WordPress vs Next.js: when it is worth it. For the platform limits, read kekurangan WordPress (Indonesian).
### What do I think happens next?
This part is my prediction, not a fact. I think a chatbot will make WordPress easy to use in 2027. I also think design will be easier with editors and drag-and-drop tools. Custom code will replace many plugins, in my view. AI tools will help people write that code for their own site. Time will show if I am right.
### Should I keep, modernize or move?
If your PHP app runs on 8.3 or later and works, keep it, and update it on schedule.
If it runs on 8.2, plan the upgrade before 31 Dec 2026.
If it runs on 8.1 or older and breaks on upgrade, that is a modernization job.
If WordPress works for your editors but the front end is slow or limited, consider headless WordPress.
If you have already decided to leave WordPress, read migrasi WordPress ke Next.js (Indonesian). For background, read tentang Next.js dan PHP (Indonesian).
### Verdict
PHP and WordPress are both alive. The real deadline is version support, and php.net publishes those dates in advance. Check your version, plan around the support table, and move only when the stack blocks the product you need. If your app is the kind that breaks on every upgrade, this is how I approach PHP modernization.
---
## WordPress Security Checklist for Business Websites
URL: https://madebyaris.com/blog/wordpress-security-checklist
Published: 2026-10-27. Updated: 2026-10-27.
Your business site runs on WordPress. It works, the leads come in, and the dashboard shows a red number next to Plugins that nobody has clicked for a while. Is the site safe, and what should someone actually do each month to keep it that way?
WordPress is still the top choice on hosting in Indonesia, and I still work with it. That is why I treat a plugin update on a live site as real work.
So this is the monthly routine I would run on a business site, with the commands and settings I would use. It starts with two updates that cannot wait for next month.
### Which updates do I need right now?
On 22 Sep 2026, WordPress 7.1.2 fixed a flaw in WordPress core. It is CVE-2026-87902, a path traversal through get_page_template(). The flaw has two ratings: WordPress calls it critical, and the NVD record shows 8.1 HIGH (CISA-ADP). NVD data shows fixes back to the 4.7 branch, in 4.7.37. If your site is on 7.1, you need 7.1.2 or later, and if it is on an older branch, take the latest release on that branch.
On 21 Oct 2026, the PHP project fixed two remote code execution flaws in PHP itself, CVE-2026-109618 and CVE-2026-109619. The ratings differ by source. The PHP project scores both 9.2 CRITICAL, while NVD scores CVE-2026-109618 at 9.8 CRITICAL and CVE-2026-109619 at 8.1 HIGH.
These PHP flaws are not in WordPress, and WordPress plans no update for them. Your server needs PHP 8.5.12, 8.4.27, 8.3.36 or 8.2.35. The PHP project says the risk is highest for mod_php. PHP 8.1 and older get no project updates, except minimal source backports for 7.4, 8.0 and 8.1, and the release notes say the temporary mitigations do not make an installation safe.
You can see both versions in Tools > Site Health > Info. If you have shell access with WP-CLI, I would check from the server instead:
```
wp core version
php -v
```
### Why is WordPress a target at all?
WordPress runs 39.6% of all websites, per W3Techs on 27 Oct 2026. It runs 58.3% of sites with a known CMS, per the same page. Anything that common is worth automating attacks against.
Risk comes from four places. Core has its own security releases, as above. Plugins and themes add code from many authors. Hosting decides the PHP version and the server settings. The monthly routine below touches all four.
### How do updates work, and what should I update by hand?
WordPress has run background updates since version 3.7, for four types: core, plugin, theme and translation. Since 5.6, new installs auto-update minor and major core releases, while older installs keep their old behavior. So a site set up years ago may not behave like a fresh one. Check your own setting in the update guide.
For plugins and themes, I would update on staging first, click through the pages that make money, then update live.
```
wp plugin list --update=available
wp plugin update --all
```
### Do my backups actually restore?
A backup you never restored is a guess. Restore one to a staging copy each month, and check that the site loads and that you can log in. The WordPress backup guide covers the files and the database. Both matter, because a database without the uploads folder is a site with no images.
### Who still has an account?
Remove accounts nobody uses, and give each person the lowest role that does the job. The intern from two years ago does not need to be an Administrator.
```
wp user list --role=administrator
```
### Is the login hardened?
Two-factor login is not in core. The wordpress.org Two Factor plugin adds it. Version 0.17.0 has 100,000+ active installs and needs WordPress 7.0 or later. I would also limit failed login attempts, so a password guesser has to be patient as well as lucky.
### Which plugins and themes should go?
Delete what you do not use. A deactivated plugin is still code on the server, and it still needs updates you will forget to run. The same goes for the default themes nobody switched to.
### Is the PHP version current?
WordPress recommends PHP 8.3 or later. It also recommends MariaDB 10.11+ or MySQL 8.0+, and HTTPS.
Many sites are behind. The wordpress.org stats API shows about 34% of WordPress sites on PHP older than 8.2. That figure is the total of the API values for those versions. Those sites get no fix from the PHP project for the October flaws, except the minimal backports.
### Which settings would I harden once?
The Hardening WordPress guide covers file permissions, database security, wp-admin, backups, logging and monitoring. Two settings from that guide go straight into wp-config.php:
```
define( 'DISALLOW_FILE_EDIT', true );
```
This turns off the theme and plugin editor in the dashboard, so a stolen admin login cannot edit PHP files from the browser. The guide also lets you move wp-config.php one folder above the web root, if your host allows it.
I would also set fresh security keys and salts, serve every page over HTTPS, and add security headers.
### What if the site is already hacked?
The wordpress.org FAQ My site was hacked gives the full process. I would start with five steps:
- Put the site in maintenance mode or take it offline.
- Change all admin, hosting, database and SFTP passwords.
- Restore a clean backup from before the hack.
- Update core, plugins, themes and PHP.
- Find how they got in before you go live again.
If you skip step 5, the hole that let them in is still open after the restore.
### Verdict
WordPress is safe enough for a business site when somebody owns the routine. Update core and PHP for the two flaws above now, then run the same short list each month: updates on staging, a restore test, a user review, a login check, a plugin cleanup and the PHP version. If nobody on your side has the time to own that list, this is how I handle WordPress maintenance.
---
## React Security: Patch, Check and Harden Your Next.js App
URL: https://madebyaris.com/blog/react-nodejs-security-checklist
Published: 2026-10-27. Updated: 2026-10-27.
You ship a Next.js app on the App Router. Someone in the team chat posts a link about a React Server Components vulnerability with a CVSS score of 10.0, and the next message is “are we affected?” Nobody answers for a while, because nobody is sure which package versions the app actually runs.
This is how I would answer that question, then how I would check the everyday React and Node.js risks while the repo is open anyway.
### What was the React Server Components vulnerability?
On 3 Dec 2025, React disclosed CVE-2025-55182, and React rates it CVSS 10.0. It sits in the server packages that run Server Components: react-server-dom-webpack, react-server-dom-parcel and react-server-dom-turbopack. The affected versions are 19.0, 19.1.0, 19.1.1 and 19.2.0.
On 11 Dec 2025, React disclosed more flaws in the same area. CVE-2025-55184 and CVE-2025-67779 are denial of service flaws, rated 7.5, and CVE-2025-55183 exposes source code, rated 5.3. Some early fixes were incomplete, so React says to use 19.0.4, 19.1.5, 19.2.4 or later. On 26 Jan 2026, React updated the post again with CVE-2026-23864, rated 7.5.
The latest React release is 19.3, from 9 Sep 2026. So the advisory history is long, and the safe reading is that “we patched in December” does not settle anything.
The first thing I would run is a list of what is installed, from the lockfile, without guessing:
```
npm ls react react-dom next
npm ls react-server-dom-webpack react-server-dom-parcel react-server-dom-turbopack
```
### Does it affect my Next.js app?
Next.js tracked this as CVE-2025-66478. Next.js 14.x stable, the Pages Router and the Edge Runtime were not affected. That first fix is now old, though. On 14 Oct 2026, Next.js shipped more security fixes on its LTS lines, so the answer is to use the latest patch for your line, and not to stop at the December 2025 fix.
Your setup |
What I would do |
App Router on Next.js 15 or 16 |
Update to the latest patch on your line |
Next.js 14.x stable or Pages Router only |
Not affected by CVE-2025-66478; still take the latest patch |
Edge Runtime only |
Not affected by CVE-2025-66478; still take the latest patch |
To see how far behind the app is, I would start with this:
```
npm outdated next react react-dom
```
Then I would pin the newest patch on the same major line, run the build and the tests, and only then think about a major upgrade. For what changed in recent releases, see Next.js 16.4 (Indonesian).
### Where does raw HTML get into the page?
The React docs warn that dangerouslySetInnerHTML can introduce an XSS vulnerability. At least the name is honest about it. I would search for every use and trace where the HTML comes from:
```
grep -rn "dangerouslySetInnerHTML" app components src
```
Each hit should get HTML you trust or have sanitized. If the answer to “where does this come from” is “a form field”, that is the bug.
### Are secrets leaking into the browser bundle?
Next.js puts only NEXT_PUBLIC_ variables into the browser bundle, and other variables stay on the server. So a NEXT_PUBLIC_ name means the value is public, whatever the variable is called. I would list them and read each one:
```
grep -rn "NEXT_PUBLIC_" .env* app src
```
An API secret with that prefix is a public API secret. Move it to a server-side variable, and rotate it, because it already shipped.
### Is auth checked on the server?
A check in a component hides a button. It does not protect the data behind it. Every route handler and Server Action that reads or writes data needs its own session check on the server, for example:
```
"use server";
export async function deleteInvoice(id: string) {
const session = await getSession();
if (!session) throw new Error("Unauthorized");
// delete only after the check
}
```
getSession here stands for whatever auth helper the app already uses. For route patterns, see Next.js App Router API.
### What about the Node.js side?
npm audit sends a description of your dependencies to the registry and reports known vulnerabilities. It exits with a non-zero code when it finds any, so it can fail a CI job. By default it needs a package-lock or shrinkwrap file. npm writes package-lock.json when it changes your dependency tree, so commit that file and let CI read it.
```
npm ci
npm audit --omit=dev
```
Keep secrets in server-side variables and out of the logs. Validate every request body on the server, and add rate limits to login, signup and any costly endpoint. The OWASP input validation cheat sheet covers the checks.
### Which Node.js line should I run?
On 27 Oct 2026, Node.js 22 and 24 are in maintenance, and Node.js 26 starts Active LTS on 28 Oct 2026. Node.js 20 reached end of life on 30 Apr 2026, so an app still on 20 is running without security fixes.
Line |
Status |
End of life |
20 |
ended |
30 Apr 2026 |
22 |
maintenance |
30 Apr 2027 |
24 |
maintenance since 20 Oct 2026 |
30 Apr 2028 |
26 |
Active LTS from 28 Oct 2026 |
30 Apr 2029 |
```
node -v
```
### What about AI-written code?
On my own side projects, I let AI agents write code. On company work, I do not trust AI code until I read it and test it. I also keep dependencies few. If I can write a small part myself, I do not install a package for it.
AI tools write code fast, and they can copy an unsafe pattern just as fast. I would review that code like any other pull request, with the same searches as above. The PR review checklist for AI-generated code is the list I would use. For the long-term cost, read technical debt in AI-built apps (Indonesian).
### Verdict
If the app runs the App Router, update React and Next.js to the latest patch on your line today, and treat the December 2025 versions as a floor you have already passed. Then spend the same afternoon on raw HTML, NEXT_PUBLIC_ variables, server-side auth checks, npm audit in CI and the Node.js line. If the update breaks the build and you want help getting it green, this is how I handle code fixing.
---
## PHP Security: What to Check First in an Older PHP App
URL: https://madebyaris.com/blog/php-security-checklist
Published: 2026-10-27. Updated: 2026-10-27.
You have a PHP app that was built years ago. It still takes orders, or bookings, or leads, and nobody wants to touch it because the last person who knew the code left. Then a security headline about PHP shows up in your feed, and the question is simple: is my app exposed, and what do I fix first?
This is how I would check an app like that, in the order I would do it. The first step happens on the server.
### Is my PHP version already the problem?
On 21 Oct 2026, the PHP project shipped a critical security release for two flaws that allow unauthenticated remote code execution. The ids are CVE-2026-109618 and CVE-2026-109619. The flaws are in PHP itself, so they affect PHP installs that serve web requests, and the PHP project says the risk is highest for mod_php.
The ratings depend on who you ask. The PHP project scores both 9.2 CRITICAL (CVSS 4.0). NVD scores CVE-2026-109618 at 9.8 CRITICAL and CVE-2026-109619 at 8.1 HIGH. Either way, I would put it on this week.
The fixed versions are 8.5.12, 8.4.27, 8.3.36 and 8.2.35. Within each branch, older releases are vulnerable. PHP 8.1 and older get no project updates, except minimal source backports for 7.4, 8.0 and 8.1. The release notes list temporary mitigations, and they also say those mitigations do not make an installation safe. I read that as “update, do not tune”.
The first thing I would run on the server is this:
```
php -v
php -i | grep -i "session.cookie"
```
The first line gives the version. The second shows the session cookie settings, which you will need later. If the site runs WordPress, there is no WordPress update for this. WordPress shows the PHP version in Tools > Site Health > Info > Server, and the fix is a PHP update on the host.
### Which PHP versions still get fixes?
This is the php.net support table on 27 Oct 2026.
Version |
Active support until |
Security fixes until |
8.2 |
ended |
31 Dec 2026 |
8.3 |
ended |
31 Dec 2027 |
8.4 |
31 Dec 2026 |
31 Dec 2028 |
8.5 |
31 Dec 2027 |
31 Dec 2029 |
The latest stable release is 8.5.12. PHP 8.2 stops getting security fixes in about two months, so an app on 8.2 is fine today and on borrowed time in January.
Old versions are common. The wordpress.org stats API shows about 34% of WordPress sites on PHP older than 8.2. That number covers WordPress sites only, and it is the total of the API values for those versions. It still tells you that “we never upgraded” is a normal state for many sites.
### Is PHP itself insecure?
The language gets security fixes on a public schedule. Old versions do not. Once the version is current, the rest of the work is in your own code, and the OWASP Top 10 is a good map. The current edition is 2025. Injection is A05, Cryptographic Failures is A04, and Software Supply Chain Failures is A03. Those three are where I would start reading an old PHP codebase, so they get their own sections below.
### How do I stop SQL injection?
Do not build a query string out of user input. Use prepared statements with PDO, so the database treats the input as data and never as SQL.
```
$stmt = $pdo->prepare("SELECT id, email FROM users WHERE email = :email");
$stmt->execute(["email" => $_POST["email"]]);
$user = $stmt->fetch();
```
When I read an old app, I search for queries glued together with a dot and a request variable. Every hit is a candidate.
### How do I stop XSS?
Escape every value at output time, for the context it lands in, such as HTML body or an attribute. htmlspecialchars is the basic tool for HTML. A Content-Security-Policy header is a good second layer. The OWASP XSS cheat sheet covers the contexts.
```
echo htmlspecialchars($comment, ENT_QUOTES, "UTF-8");
```
### How should I store passwords?
Use password_hash and password_verify, and nothing you wrote yourself. PASSWORD_DEFAULT uses bcrypt today, and the php.net manual says this default can change over time. So store the full hash string and give the column room to grow.
```
$hash = password_hash($password, PASSWORD_DEFAULT);
if (password_verify($input, $hash)) {
// log the user in
}
```
If the old app stores md5 hashes, that is the moment to plan a rehash on next login.
### What about file uploads?
Treat every upload as hostile. Check the type on the server, store files outside the web root, and never let an uploaded file run as code. The OWASP file upload cheat sheet lists the full set of checks. The question I would ask is short: if someone uploads a file named shell.php, can the web server run it?
### Are the session defaults safe?
Not for a production site. The php.ini defaults are session.cookie_httponly “0”, session.cookie_secure “0”, an empty session.cookie_samesite, and session.use_strict_mode “0”. That is four settings left for you to decide.
```
session.cookie_httponly = 1
session.cookie_secure = 1
session.cookie_samesite = "Lax"
session.use_strict_mode = 1
```
Add a CSRF token to every form that changes data, too.
### Are my dependencies safe?
composer audit checks your installed packages for known security vulnerabilities. Composer added it in version 2.4.0, and you can also run install or update with the –audit flag.
```
composer audit
composer update --audit
```
### What would my own check list look like?
- Run php -v and compare it with the fixed versions above.
- Search the code for queries that join strings with user input.
- Search for echo or print of request data without escaping.
- Check how passwords are stored.
- Check where uploads go, and whether that folder can run PHP.
- Read the session settings in php.ini.
- Run composer audit.
### When is a patch not enough?
A patch fixes one flaw. It does not fix an app that cannot move to a supported PHP version. Some apps break on each upgrade, and some have no tests, so nobody trusts a change. If your app runs PHP 8.1 or older, a version bump is a project that needs its own plan and tests.
### Verdict
Update PHP first, because the October flaws sit in PHP itself and no code review fixes them. Then read your queries, your output, your passwords, your uploads and your session settings, in that order. If the upgrade itself is the wall you keep hitting, that is a modernization job, and this is how I approach PHP modernization.
---
## Grok Bot untuk kantor: inbox, riset, dan expense di komputer cloud
URL: https://madebyaris.com/blog/grok-untuk-kantor
Published: 2026-10-24. Updated: 2026-10-24.
Grok Bot mengerjakan tugas kantor di komputer cloud yang punya browser, file, dan command line. Pekerjaannya tetap berjalan walaupun aplikasi atau laptop kamu ditutup.
Saya Aris Setiawan. Penjelasan dasarnya ada di Mengenal Grok Bot, dan versi Inggris untuk kerja kantor ada di Grok Bot for office work. Di sini saya menulis dari sisi orang yang memegang inbox dan persetujuan.
### Apa bedanya dengan chat
Dengan chat, kamu menempelkan email, membaca ringkasannya, lalu menyalin hasilnya kembali. Tool kantornya tetap tertutup selama proses itu.
Grok Bot membuka tool tersebut sendiri. Ada tool yang terhubung sebagai app, dan ada yang dibuka lewat browser. Halaman resminya ada di x.ai/bot.
### Satu komputer untuk semua Bot
Semua Bot dalam satu akun memakai satu komputer cloud yang sama. Cookie browser dan sesi login juga ikut dipakai bersama. Karena itu nama Bot hanya berfungsi sebagai label, dan Bot kedua tidak bisa dijadikan tempat aman untuk password penting.
### Tugas yang bisa diserahkan
Daftar berikut berisi tugas yang sudah ada di meja kantor, beserta bagian yang tetap saya pegang:
- Inbox: Bot meringkas thread dan menyiapkan draf balasan, sedangkan pengirimannya tetap di tangan saya.
- Riset: Bot membuka sumber dan menulis ringkasan, sedangkan kalimat dari sumber yang tidak bisa saya buka tidak saya pakai.
- Expense: Bot mengisi form dari struk, sedangkan angkanya tetap saya setujui.
- Catatan rapat: Bot merangkum rapat menjadi satu halaman, sedangkan bagian yang terlalu panjang saya potong.
Mulailah dari satu tugas untuk satu Bot. Pilih tugas yang perintahnya muat dalam lima kalimat.
### Langkah yang tetap diketik sendiri
Untuk password, kode 2FA, atau CAPTCHA, kamu sendiri yang mengisinya. Bot menyerahkan layar komputer bersama ke kamu lewat computer takeover. Pembelian dan transfer uang menunggu persetujuan kamu lebih dulu.
Auto-review memeriksa tool call dan aksi di komputer. Aturannya bisa diatur menjadi “Ask first” atau “Allow automatically”, dan setiap permintaan punya pilihan “Allow once”, “Always allow”, atau “Deny”. Persetujuan tidak membatalkan pekerjaan yang sudah selesai, jadi atur aturan “Ask first” sebelum Bot masuk ke inbox kerja.
Akses dan paket Grok Bot dijelaskan di Mengenal Grok Bot.
Terakhir dicek: 24 Oktober 2026.
Jadi, Bot bisa mengerjakan langkah kantor, tetapi keputusan dan login tetap di tangan kamu. Langkah pertamanya cukup memilih satu tugas inbox dan menuliskannya sebagai satu permintaan ke satu Bot.
---
## Grok Bot for office work: inbox, expenses and research
URL: https://madebyaris.com/blog/grok-bot-for-office-worker
Published: 2026-10-24. Updated: 2026-10-24.
Office work is inbox, expenses, research and status checks in tools with no API. These are the jobs I would give a Grok Bot first. For what the app is, read the Grok Bot intro.
I am Aris Setiawan. I ship Next.js for client work. This post is my plan for an office desk.
### Jobs I would hand a Bot
I name each Bot for its job, so the name tells me what it does. The name is only a label. All Bots on one account share one cloud computer.
The product page shows example Bots such as Sales Outbound, Expense Manager and Account Health. I give no time savings for them.
This list shows the jobs I would hand off and the step that I keep:
Job | What the Bot does | What I keep |
Inbox | Drafts replies, sorts mail, pulls threads before a meeting | I send any reply that commits us |
Expenses | Exports the month, matches receipts, flags gaps | I approve the spend |
Research | Opens sources and writes a brief into /workspace | I decide what we believe |
Meeting prep | Collects the agenda, the last email and open tickets | I lead the meeting |
Status checks | Uses a connected app, or the website in the browser | I check the result |
A Bot can keep working when I close the laptop. Closing the app does not stop a background turn.
### What I still type myself
Passwords, two-factor codes and CAPTCHAs come back to me through a computer takeover. Purchases and financial transfers wait for my approval.
Auto-review checks tool calls and computer actions. I can set “Ask first” or “Allow automatically” rules. A prompt offers “Allow once”, “Always allow” or “Deny”. The intro post explains what an approval cannot undo.
Browser cookies and signed-in sessions belong to the shared computer, not to one Bot. So I do not use a second Bot as a safe place for production credentials.
### How I would set it up
- Install the app on the computer or phone I use. The FAQ lists the supported systems.
- Sign in with the plan I have. Grok Bot uses Cursor authentication.
- Name one Bot each for inbox, expenses and research.
- Sign each Bot into its tools, watch the first run and type the codes.
- Make a skill for the task. Add a routine only after one run finishes well.
Teach a task can record a browser workflow into a draft skill. The recording has a ten minute limit. The rollout may be gradual, so some accounts may not have it yet.
Last checked: 24 October 2026.
Start with one office job that you can check in five minutes. Today, pick that job and write it as a single request to one Bot.
---
## Mengenal Grok Bot, aplikasi xAI untuk mengerjakan tugas di komputer cloud
URL: https://madebyaris.com/blog/mengenal-grok-bot
Published: 2026-10-24. Updated: 2026-10-24.
Grok Bot adalah aplikasi dari xAI yang halamannya ada di x.ai/bot. Kamu memberi nama dan tugas ke sebuah Bot, lalu Bot itu bekerja di komputer cloud dan membuka tool yang biasa kamu pakai.
Saya Aris Setiawan, developer Next.js untuk proyek klien. Sebelum aplikasi ini saya hubungkan ke akun mana pun, saya ingin paham dulu cara kerjanya. Versi Inggrisnya ada di Grok Bot.
### Tiga hal yang sama-sama bernama Grok
Grok di grok.com dan di X adalah chat yang menjawab pertanyaan. Di Cursor, Grok muncul sebagai salah satu nama model. Grok Bot berbeda dari keduanya karena ia mengerjakan tugas di sebuah komputer.
Aplikasinya tersedia untuk Mac, Windows, dan Linux. Versi Linux tersedia sebagai paket .deb, .rpm, atau AppImage untuk x64 dan Arm64. Di ponsel dan tablet, syaratnya minimal iOS 18, iPadOS 18, atau Android 9.
### Cara kerjanya
Setiap Bot bisa memakai browser, command line, file, dan tool yang sudah terhubung. Semua Bot dalam satu akun memakai satu komputer yang sama, termasuk cookie dan sesi login di browser-nya. Dokumentasi xAI menegaskan bahwa Bot yang berbeda tidak bisa dijadikan batas keamanan.
Tool tertentu terhubung sebagai app, yang dipasang sebagai plugin lewat menu Connect apps. Tool tanpa plugin tetap bisa dipakai, karena Bot membuka website-nya lewat browser.
Untuk password, kode 2FA, atau CAPTCHA, kamu sendiri yang mengisinya. Bot menyerahkan layar komputer bersama ke kamu lewat computer takeover. Pembelian dan transfer uang menunggu persetujuan kamu. Persetujuan itu tidak membatalkan pekerjaan yang sudah selesai, jadi pahami dulu batas ini sebelum Bot masuk ke email kamu.
Skill berisi cara mengerjakan sebuah tugas, sedangkan routine menentukan kapan tugas itu jalan. Saya memisahkan keduanya supaya tidak ada tugas yang terjadwal sebelum saya melihatnya selesai satu kali.
### Akses dan paket
xAI merilis Grok Bot dalam status beta pada 11 Agustus 2026.
Login-nya memakai autentikasi Cursor. Grok Bot tidak dijual terpisah. Di The X Subscription, Grok Bot termasuk dalam paket Premium, Super, dan Ultra, tetapi tidak termasuk dalam Plus dan Free.
SuperGrok adalah langganan terpisah yang bisa ditautkan ke paket Cursor lama. Paket Cursor berbayar yang lama juga sudah termasuk Grok Bot.
Untuk tim, ada dua jalur yang sudah termasuk Grok Bot: seat tim di The X Subscription dan paket Cursor Teams lama yang self-serve. Akses Enterprise diatur lewat admin atau tim akun, jadi tanyakan langsung ke tim sales.
### Sumber yang saya baca
Saya mulai dari x.ai/bot, lalu membaca Introducing Grok Bot (11 Agustus) dan Grok Bot is now included with more plans (26 Agustus). Soal komputer bersama ada di Computer and apps, soal login dan persetujuan ada di Approvals, security, and privacy. Daftar perangkat dan paket ada di FAQ.
Terakhir dicek: 24 Oktober 2026.
Jadi, semua Bot di satu akun berbagi satu komputer, dan langkah login tetap ada di tangan kamu. Langkah pertamanya cukup membuka FAQ Grok Bot dan mencocokkan perangkat serta paket yang kamu punya.
---
## Grok Bot: what the xAI app is and what it can do
URL: https://madebyaris.com/blog/grok-bot
Published: 2026-10-24. Updated: 2026-10-24.
Grok Bot is an app from xAI, at x.ai/bot. You give a named Bot a job. The Bot works on a cloud computer, and it can open the tools you already use.
I am Aris Setiawan. I ship Next.js for client work. I wanted to know what this app does before I signed it into my accounts.
### Same word, three products
The Grok chat on grok.com and on X answers what you type. In Cursor, Grok is a model name in the model list. Grok Bot is a third thing: an app that does work on a computer.
The app runs on Mac, Windows and Linux. Linux builds come as a .deb, .rpm or AppImage package, for x64 and Arm64. Phones and tablets need iOS 18, iPadOS 18 or Android 9, or a later version.
### What it is
You name a Bot and you give it work. The Bot can use a browser, a command line, files and connected tools.
All Bots on one account share one computer. Browser cookies and signed-in sessions are shared too. The docs say that separate Bots are not a security boundary.
Some tools connect as apps. The app installs them as plugins from Connect apps. For a tool with no connector, the Bot uses the website in the browser.
Some steps come back to you. You type passwords, two-factor codes and CAPTCHAs through a computer takeover. Purchases and financial transfers need your approval.
An approval does not reverse work that is already complete. Read that line before you sign a Bot into your email.
A skill describes how to do a task. A routine tells the Bot when to run. I do not schedule a task before I see it finish once.
### Access and plans
xAI launched Grok Bot in beta on 11 Aug 2026.
Grok Bot uses Cursor authentication. Grok Bot is not sold alone. On The X Subscription, Premium, Super and Ultra include Grok Bot. Plus and Free do not include it.
SuperGrok is a separate subscription. You can link it to a legacy Cursor plan. Legacy paid Cursor plans also include Grok Bot.
For teams, two paths include Grok Bot. One is a team seat on The X Subscription. The other is a legacy self-serve Cursor Teams plan. Enterprise access goes through an admin or account team; check with sales.
### What I read
I started at x.ai/bot. Then I read the launch post from 11 Aug, Introducing Grok Bot. The access post from 26 Aug is Grok Bot is now included with more plans.
For the shared computer, I read Computer and apps. For logins and approvals, I read Approvals, security, and privacy. The FAQ has the platform list and the plan details.
Last checked: 24 October 2026.
All Bots on your account work on one shared cloud computer. Treat them as one desk. Today, open the FAQ and check that your device and plan are on the list.
---
## AI ROI for small businesses: how to judge your AI tool spending in 2026
URL: https://madebyaris.com/blog/ai-roi-small-business
Published: 2026-10-18. Updated: 2026-10-18.
On Friday, 16 October 2026, the Nasdaq Composite fell 2.14%, per CNN Business, accessed 18 October 2026. Investors had questions about the debt that some AI companies use to grow. If you pay for AI tools in a small business, use this news to check your AI ROI. AI ROI (return on investment) compares the value that each tool gives you with its cost.
### Short answer
List every paid AI tool. Give each tool one job and one measure. Compare the monthly cost with the time or money that the tool saves. After 30 days, cancel each tool that has no measure.
### What the AI debt news means for a small business
Large AI companies spend a lot of money on data centers. Some of this money is borrowed. The Bank for International Settlements calls some of it “shadow borrowing”, per BIS Quarterly Review, accessed 18 October 2026. The review describes obligations that are “economically akin to debt but largely reside outside corporate balance sheets”. Investors worry that this spending will not pay back.
A small business does not borrow for data centers. The same question applies to your tool bill: does the money you spend come back as value? AI vendors can also change their billing model. GitHub Copilot moved to usage-based billing on 1 June 2026, per the GitHub blog, accessed 18 October 2026. GitHub kept its base plan prices, but the bill now depends on usage.
A U.S. Census Bureau working paper gives data about how US firms used AI. Of all US firms, 18% used AI in a business function, per CES Working Paper 26-25, accessed 18 October 2026. The period was November 2025 to January 2026. The survey sample frame was about 1.2 million US businesses. This is a working paper, not an official Census publication. It does not give an ROI figure.
### Step 1: List each AI tool and its monthly cost
Open your bank statement and your card statement. Find each AI subscription. Write the tool name, the plan, the number of seats, and the monthly cost. Include tools inside other products, for example an AI add-on in your email or design software.
If you find a tool that nobody uses, cancel it now.
### Step 2: Give each tool one job and one measure
Write one job for each tool in one sentence. For example: “This tool writes the first draft of product descriptions.” Then write one measure that you can count:
- Time: hours that the team saves each week.
- Output: drafts, tickets, or pages that the team completes.
- Money: sales, leads, or costs that change because of the tool.
If you cannot write a job, the tool has no job. If you cannot write a measure, you cannot judge the tool.
### Step 3: Compare the cost with the time saved
Multiply the hours saved by the hourly cost of the person who does the work. Compare the result with the monthly cost of the tool. Collect data for 30 days. Do not use estimates from the vendor. Use your own records, for example time logs or the number of closed tickets.
If you pay for Cursor, you can read my notes on Cursor AI pricing to see how the plans operate.
### Step 4: Check the hidden costs
Ask these questions about each tool before you decide:
- Seats: do you pay for people who left or do not use the tool?
- Usage limits: what happens when you go over the limit?
- Data exports: can you take your data out in a usable format?
- Lock-in: how much work is it to move to a different tool?
- Review time: how long does a person need to check the output?
### Step 5: Keep, reduce, or cancel
Use your measures to make one decision for each tool:
- Keep: the value is clearly more than the cost.
- Reduce: the tool helps, but the plan is too large. Move to a smaller plan or fewer seats.
- Cancel: the tool has no job, no measure, or the cost is more than the value.
Do this review again every quarter. Tools change, and your business changes.
### A simple AI spending review template
Copy this table. The figures are examples only. They are not real data.
Tool (example) | Job | Measure | Monthly cost | Monthly value | Decision |
Writing assistant | First drafts of product text | 6 hours saved | USD 20 | USD 90 | Keep |
Meeting notes tool | Summaries of client calls | Not used in 30 days | USD 15 | USD 0 | Cancel |
Image generator, 5 seats | Social media images | 2 active seats | USD 100 | USD 60 | Reduce to 2 seats |
If one AI feature is part of your website, read what AI integration services include. Some features do not need a large model. My notes on when a website needs machine learning explain that decision. For tasks with many steps, see AI agent development.
### Frequently asked questions
#### How do I calculate the ROI of an AI tool?
Subtract the monthly cost from the monthly value, then divide the result by the monthly cost. For the value, use the time result from Step 3, or use the extra sales from the tool. If you cannot find a value, the ROI is unknown, and the tool is a candidate to cancel.
#### How long should I test an AI tool before I decide?
Use 30 days for most tools, and write the job and the measure on day one. If the work happens only once a month, for example a monthly report, test for two cycles. Keep a short log with dates and hours, because a log gives better data than an opinion at the end.
#### Do AI stock drops change the price of AI tools for small businesses?
I cannot show a direct link between a stock drop and the price of a tool. The billing model can change, so save the price page and the billing terms on the day that you subscribe. At each quarterly review, compare the saved pages with the current pages to find differences early.
#### Which costs do AI tool price pages not show?
The hidden costs are unused seats, charges above a usage limit, review time, and the cost to leave a tool. To find them, check your invoices for unused seats and usage charges, and ask the team about weekly review time. Then try one data export, so that you see what leaving the tool involves.
### Next step
Keep only the AI tools that have a job and a measure. List your paid AI tools and their monthly costs in the template above. Do you want an AI feature with a clear measure from the first day? Send me the task through AI integration services. I reply within 24 hours and tell you plainly whether I am the right fit for the task. You can also see all my AI development services.
---
## Cara membuat bracket turnamen bulu tangkis interaktif dengan Next.js
URL: https://madebyaris.com/blog/bracket-turnamen-nextjs
Published: 2026-10-18. Updated: 2026-10-18.
BWF World Junior Championships 2026 berlangsung di Kairo pada 12 sampai 17 Oktober, sesuai halaman turnamen di situs BWF. Kalau klub kamu menggelar turnamen internal dengan bagan yang digambar di kertas atau di spreadsheet, bagan itu harus difoto ulang dan dikirim ke grup setiap kali ada pemenang baru.
### Jawaban singkat
Untuk turnamen sekali jalan, generator bracket gratis sudah cukup. Bracket buatan sendiri dengan Next.js masuk akal kalau klub ingin bagan itu ada di website-nya sendiri, dengan URL, data, dan tampilan milik klub, serta pemenang yang naik ke babak berikutnya secara otomatis. Project di tutorial ini terdiri dari empat bagian, yaitu pasangan perempat final, pasangan babak berikutnya yang diambil dari pemenang, tampilan tiga babak, dan logika memilih pemenang.
### Kapan cukup pakai generator gratis, kapan perlu bracket sendiri?
Sebelum memilih, jawab tiga pertanyaan berikut. Apakah hasil turnamen perlu tetap bisa dibuka di website klub tahun depan? Apakah bracket perlu tampil dengan nama, warna, dan alamat website klub sendiri? Apakah ada orang yang bisa merawat kodenya setelah turnamen selesai? Kalau ketiga jawabannya tidak, generator gratis lebih hemat waktu.
### Hasil akhir: bracket yang terisi otomatis
Hasilnya berupa bracket sistem gugur untuk 8 pemain dengan tiga babak, yaitu perempat final, semifinal, dan final. Pemenang yang kamu pilih otomatis muncul di babak berikutnya, dan nama pemain di demo adalah nama contoh (fiktif). Saya membangun demo ini dengan bantuan AI coding agent, lalu hasilnya saya cek sendiri.
### Yang kamu perlukan
Versi yang dipakai adalah Next.js 16.4.2 (App Router), React 19.3.0, dan Tailwind CSS v4, jadi kamu perlu Node.js yang bisa menjalankan versi Next.js itu dan pemahaman dasar tentang komponen React dan hook seperti useState. Kalau App Router masih baru buat kamu, baca dulu App Router dalam praktik.
### Langkah 1: tulis pasangan perempat final
Bracket ini dibuat untuk nomor tunggal, dan setiap slot berisi satu nama pemain. Empat pasangan perempat final ditulis langsung di kode, lalu state bracket menyimpan pemenang setiap babak, yang awalnya masih kosong.
Komponen BadmintonBracket, pasangan perempat final:
```
const QUARTER_PAIRINGS: [string, string][] = [
["Andi Wijaya", "Budi Santoso"],
["Citra Dewi", "Dedi Pratama"],
["Eka Putri", "Fajar Nugroho"],
["Gita Rahma", "Hadi Susilo"],
];
interface BracketState {
quarterWinners: (string | null)[];
semiWinners: (string | null)[];
finalWinner: string | null;
}
const initialState: BracketState = {
quarterWinners: [null, null, null, null],
semiWinners: [null, null],
finalWinner: null,
};
```
### Langkah 2: susun semifinal dan final dari pemenang
Pasangan semifinal dan final tidak ditulis di kode, karena keduanya baru terbentuk setelah pemenang babak sebelumnya dipilih. Semifinal pertama mempertemukan pemenang perempat final pertama dan kedua, semifinal kedua mempertemukan pemenang ketiga dan keempat, sedangkan final terisi setelah kedua semifinal punya pemenang.
Komponen BadmintonBracket, pasangan semifinal dan final dari pemenang:
```
const semiPairings = useMemo((): ([string, string] | null)[] => {
const w = state.quarterWinners;
const p0 =
w[0] && w[1] ? ([w[0], w[1]] as [string, string]) : null;
const p1 =
w[2] && w[3] ? ([w[2], w[3]] as [string, string]) : null;
return [p0, p1];
}, [state.quarterWinners]);
const finalPairing = useMemo((): [string, string] | null => {
const [a, b] = state.semiWinners;
return a && b ? [a, b] : null;
}, [state.semiWinners]);
```
### Langkah 3: tampilkan bracket di halaman
Setiap babak tampil sebagai satu kolom di layar lebar, sehingga ketiga babak berjajar dari kiri ke kanan, sedangkan di layar yang lebih kecil ketiganya tersusun ke bawah dalam satu kolom. Slot di semifinal dan final tampil sebagai tempat kosong sampai pemenang dari babak sebelumnya dipilih.
Komponen BadmintonBracket, tampilan tiga babak:
```
```
### Langkah 4: pilih pemenang dan naikkan ke babak berikutnya
Pemenang dipilih dengan mengetuk nama pemain, dan yang disimpan hanya nama pemenang, tanpa skor. Semua pilihan itu ada di state React di browser, jadi hasilnya hilang setelah halaman di-reload. Kalau salah pilih, pemenang bisa dikoreksi dengan mengetuk pemain lain di pertandingan yang sama, tetapi babak setelahnya ikut dikosongkan dan perlu dipilih ulang, sedangkan tombol “Reset bracket” mengosongkan semuanya.
Komponen BadmintonBracket, memilih pemenang dan reset:
```
const pickQuarter = useCallback((matchIndex: number, player: string) => {
setState((prev) => ({
quarterWinners: prev.quarterWinners.map((w, i) =>
i === matchIndex ? player : w,
),
semiWinners: [null, null],
finalWinner: null,
}));
}, []);
const pickSemi = useCallback((matchIndex: number, player: string) => {
setState((prev) => ({
...prev,
semiWinners: prev.semiWinners.map((w, i) =>
i === matchIndex ? player : w,
),
finalWinner: null,
}));
}, []);
const pickFinal = useCallback((player: string) => {
setState((prev) => ({ ...prev, finalWinner: player }));
}, []);
const reset = () => setState(initialState);
```
### Langkah 5: rencana untuk turnamen sungguhan
Karena hasil di demo hanya tersimpan di browser, turnamen sungguhan membutuhkan dua tambahan, yaitu database untuk menyimpan pemenang supaya hasilnya tidak hilang setelah reload, dan hosting supaya panitia cukup membagikan satu link. Kalau kamu ingin memakai server sendiri, langkahnya ada di deploy Next.js di VPS murah.
### Pertanyaan yang sering ditanyakan
#### Apa bedanya bracket sistem gugur dan klasemen setengah kompetisi?
Di sistem gugur, pemain yang kalah langsung tersingkir, sehingga 8 pemain hanya butuh tujuh pertandingan sampai juara ditentukan, seperti di demo ini. Di setengah kompetisi (round robin), setiap pemain bertemu semua pemain lain satu kali, jadi 8 pemain membutuhkan 28 pertandingan dan tidak ada yang tersingkir di tengah jalan. Karena bentuknya berbeda, tampilannya juga berbeda, yaitu bracket untuk sistem gugur dan tabel hasil untuk setengah kompetisi, dan yang dibangun di tutorial ini hanya sistem gugur.
#### Bagaimana cara mengatur bye kalau jumlah pemain ganjil?
Demo di tutorial ini belum menangani bye, karena ukurannya tetap 8 pemain dengan pasangan yang ditulis langsung di kode. Untuk jumlah pemain lain, kamu perlu fungsi yang membulatkan jumlah slot ke 2, 4, 8, 16 atau 32, mengisi slot kosong sebagai bye, lalu meloloskan lawan bye ke babak berikutnya secara otomatis.
#### Apakah bracket ini bisa dipakai untuk ganda dan beregu?
Bracket di tutorial ini dibuat untuk tunggal, tetapi untuk ganda kamu cukup menulis nama pasangan di slot, misalnya “Pemain A/Pemain B”. Untuk beregu, satu pertemuan berisi beberapa partai, jadi data dan tampilannya perlu diubah supaya bisa mencatat partai-partai itu dan menentukan regu yang menang. Fitur beregu ini belum ada di demo.
#### Bisakah pemenang dikoreksi setelah naik ke babak berikutnya?
Bisa, seperti dijelaskan di Langkah 4, dengan aturan pengosongan berikut:
- Pemenang perempat final yang diganti mengosongkan kedua semifinal dan final, termasuk semifinal di paruh bracket yang lain, karena fungsi pickQuarter mengisi ulang semiWinners dan finalWinner dengan null.
- Pemenang semifinal yang diganti hanya mengosongkan final.
- Pemenang final bisa diganti bebas tanpa mengosongkan apa pun.
- Ketukan kedua pada pemenang yang sama juga mengosongkan babak setelahnya.
### Penutup
Bracket di website sendiri paling berguna saat hasil turnamen klub perlu bisa dibuka lagi di satu URL milik klub. Catat dulu turnamen apa saja yang akan klub kamu gelar tahun ini. Kalau kamu ingin bracket seperti ini dibuatkan sekaligus dengan scoreboard live dengan Next.js, kirim daftar turnamen itu lewat jasa pembuatan website Next.js, dan saya balas dalam 24 jam. Kamu juga bisa melihat dulu layanan Next.js development saya.
Terakhir dicek: 18 Oktober 2026.
---
## SEO halaman jadwal: cara membuat halaman jadwal bisnis yang mudah ditemukan di Google
URL: https://madebyaris.com/blog/seo-halaman-jadwal
Published: 2026-10-18. Updated: 2026-10-18.
“Indosiar” masuk daftar pencarian yang sedang naik di Google Trends Indonesia pada 18 Oktober 2026, dengan berita dari Liputan6.com tentang jadwal sinetron siang itu pukul 13.30 WIB. Kalau gym, tempat kursus, atau klinik kamu memasang jadwal hanya sebagai gambar di Instagram, orang yang mencari jadwal itu di Google tidak menemukan halaman yang bisa dibaca.
### Jawaban singkat
Halaman jadwal yang mudah ditemukan punya satu URL tetap yang isinya diperbarui, jadwal yang ditulis sebagai teks di samping gambar apa pun, tanggal yang jelas, serta baris “terakhir diperbarui” yang terlihat. Structured data Event hanya dipakai untuk acara sungguhan di lokasi fisik yang bisa didatangi umum.
### Satu URL tetap atau satu halaman untuk setiap tanggal?
Saran saya untuk kebanyakan bisnis adalah satu URL tetap, misalnya /jadwal, yang isinya kamu perbarui setiap minggu, karena tautan dari Instagram, Google Maps, dan WhatsApp tetap mengarah ke halaman yang sama. Saran ini saya dasarkan pada cara Google menangani halaman yang mirip, yaitu dengan memilih satu URL kanonis untuk ditampilkan. Panduan Google tentang URL duplikat juga menjelaskan cara memberi tahu Google URL mana yang utama.
Pengecualiannya adalah acara yang berdiri sendiri, seperti seminar atau turnamen, yang memang layak punya halaman sendiri.
### Jadwal dalam bentuk teks, dengan alt text untuk gambar
Tulis jadwal sebagai teks HTML biasa, misalnya tabel hari, jam, dan nama kelas, lalu kalau kamu tetap ingin memasang gambar jadwal yang dibuat desainer, beri gambar itu alt text yang menjelaskan isinya. Google menjelaskan bahwa mereka memakai alt text bersama computer vision dan isi halaman untuk memahami gambar.
### Kapan structured data Event membantu, dan kapan tidak
Structured data Event dari Google punya syarat yang ketat, karena setiap event harus punya URL sendiri dengan markup di URL itu dan harus berlangsung di lokasi fisik. Event juga harus bisa didatangi umum, sedangkan acara yang hanya online, jam buka usaha, dan kupon tidak termasuk.
Artinya, jadwal siaran TV seperti jadwal sinetron tidak cocok diberi markup Event, dan jadwal kelas rutin di gym juga perlu dipikirkan dulu. Tampilan event khusus di hasil pencarian juga belum tercantum untuk Indonesia, jadi anggap markup ini sebagai cara membuat halaman lebih jelas tanpa berharap tampilan baru.
### Contoh untuk bisnis: kelas, klinik, dan event
Berikut tiga contoh hipotetis untuk menggambarkan pilihan di atas:
- Studio yoga, misalnya: satu halaman /jadwal-kelas berisi tabel mingguan dalam teks, diperbarui setiap Minggu malam, tanpa markup Event.
- Klinik gigi, misalnya: jam praktik dokter ditulis sebagai teks di satu halaman, dan karena jam buka tidak termasuk event, markup Event tidak dipakai.
- Penyelenggara workshop, misalnya: satu halaman untuk setiap workshop berbayar di lokasi tertentu, lengkap dengan markup Event, ditambah satu halaman daftar yang menautkan semuanya.
Kalau jadwal kamu untuk klub olahraga yang ingin skor ikut tampil, saya pernah menulis tutorial scoreboard live dengan Next.js.
### Checklist singkat sebelum halaman jadwal di-publish
- URL: satu alamat tetap yang tidak berubah setiap minggu.
- Isi: jadwal ditulis sebagai teks, dengan hari, tanggal, jam, dan zona waktu.
- Gambar: kalau ada, beri alt text yang menjelaskan isinya.
- Tanggal: baris “terakhir diperbarui” yang terlihat oleh pengunjung.
- Markup: Event hanya untuk acara di lokasi fisik yang bisa didatangi umum.
- Plugin: kalau jadwal kamu ada di plugin WordPress, cek apakah plugin itu menulis jadwal sebagai teks, dan baca juga risiko plugin secara umum di kekurangan WordPress.
Untuk pemeriksaan teknis yang lebih luas, gunakan checklist audit SEO teknis.
### Pertanyaan yang sering ditanyakan
#### Apakah jadwal dalam bentuk gambar bisa dibaca Google?
Google tidak menjanjikan hal itu, karena yang disebut di panduannya adalah alt text, computer vision, dan isi halaman sebagai bahan untuk memahami gambar. Panduan yang sama juga menyarankan agar gambar yang berisi teks tidak dipilih sebagai gambar utama untuk og:image, yaitu gambar yang tampil saat link dibagikan. Jadi kalau kamu membagikan link jadwal di WhatsApp atau Facebook, pakai foto atau ilustrasi biasa sebagai og:image dan biarkan jadwalnya tertulis di halaman.
#### Lebih baik satu halaman jadwal atau satu halaman per tanggal?
Untuk jadwal rutin, saya menyarankan satu halaman tetap, sedangkan posting per tanggal cocok untuk acara yang memang berbeda setiap kali. Panduan Google juga menyebut bahwa konten duplikat tidak termasuk pelanggaran spam, jadi posting jadwal lama yang sudah terlanjur ada tidak perlu dihapus dengan panik. Yang perlu kamu lakukan adalah berhenti membuat posting baru untuk jadwal rutin dan mengarahkan pengunjung ke halaman tetap itu.
#### Kapan halaman jadwal perlu structured data Event?
Ketika setiap acara punya halaman sendiri, berlangsung di lokasi fisik, dan bisa didatangi umum. Panduan umum structured data dari Google bahkan memberi contoh pelanggaran yang mirip dengan kasus jadwal TV, yaitu situs live streaming olahraga yang menandai siarannya sebagai event lokal. Jadi untuk jadwal siaran atau kelas online, cukup tulis jadwalnya sebagai teks yang rapi tanpa markup Event.
#### Kapan halaman jadwal perlu diperbarui?
Setiap kali ada perubahan, termasuk sesi yang batal, pengajar yang berganti, atau jam yang bergeser. Hapus sesi yang sudah lewat dari tabel supaya pengunjung tidak salah datang, dan ubah isi di URL yang sama tanpa membuat alamat baru. Kalau jadwal kamu juga dipasang di Google Maps atau Instagram, cocokkan ketiganya di hari yang sama supaya tidak ada dua versi jadwal yang beredar.
### Penutup
Halaman jadwal yang ditemukan di Google bertumpu pada satu URL tetap dan jadwal dalam bentuk teks, sedangkan markup Event hanya membantu untuk acara sungguhan. Buka halaman jadwal bisnis kamu dan coba blok teks jadwalnya dengan kursor, karena jadwal yang tidak bisa diblok masih berupa gambar. Kalau kamu ingin saya mengecek halaman itu, kirim URL-nya lewat halaman jasa SEO, dan saya balas dalam 24 jam.
Terakhir dicek: 18 Oktober 2026.
---
## Kenapa halaman spam live streaming bisa muncul di Google, dan apa artinya untuk website bisnis
URL: https://madebyaris.com/blog/halaman-spam-live-streaming-google
Published: 2026-10-18. Updated: 2026-10-18.
Pada 18 Oktober 2026, berita teratas untuk pencarian “leverkusen vs freiburg” di Google Trends Indonesia adalah halaman spam yang menawarkan live streaming laga Bundesliga itu, dengan judul penuh simbol aneh dan campuran kata Jerman. Pemilik website bisnis yang melihat hal seperti ini wajar bertanya kenapa halaman semacam itu bisa muncul dan apakah website mereka sendiri bisa ikut terkena dampaknya.
### Jawaban singkat
Pada 18 Oktober, halaman spam itu menumpang pada pencarian laga yang baru ramai, dan Google sendiri pernah menulis bahwa untuk topik baru, informasi yang terbit paling awal belum tentu yang paling bisa diandalkan. Taktik seperti ini termasuk black hat SEO, yaitu cara mengejar ranking dengan melanggar aturan mesin pencari, dan kebijakan spam Google melarangnya. Untuk website kamu sendiri, risiko yang perlu dijaga adalah halaman spam yang ditaruh lewat celah keamanan, misalnya CMS versi lama yang tidak aman.
### Apa yang terlihat di Google Trends
Di daftar pencarian yang sedang naik di Indonesia, “leverkusen vs freiburg” muncul dengan berita teratas berupa halaman yang menjanjikan siaran langsung pertandingan. Judulnya diawali deretan simbol seperti tanda seru, tanda dolar, dan kurung siku, lalu kata “Übertragung” dan “Livestream” dengan tanggal pertandingan di belakangnya. Saya sengaja tidak menautkan dan tidak menyebut nama situsnya.
Judul seperti itu disusun untuk sistem pencarian. Kebijakan spam Google mencantumkan pola serupa sebagai spam, yaitu konten yang hampir tidak masuk akal bagi pembaca tetapi berisi kata kunci pencarian.
### Kenapa halaman spam bisa muncul untuk pencarian yang sedang ramai
Untuk topik yang benar-benar baru, Google pernah menulis bahwa informasi yang terbit paling awal belum tentu yang paling bisa diandalkan. Tulisan dari 2021 itu membahas berita yang berkembang cepat dan tidak menyebut spam.
### Apakah ini termasuk black hat SEO?
Ya, karena kebijakan spam Google memberi nama untuk beberapa pola yang cocok dengan halaman seperti ini. Berikut tiga yang paling dekat dengan kasus live streaming:
- Konten massal (scaled content abuse): banyak halaman dibuat terutama untuk memanipulasi ranking pencarian, misalnya satu halaman untuk setiap laga dengan isi yang hampir sama.
- Konten hasil peretasan (hacked content): konten yang ditaruh di sebuah situs tanpa izin pemiliknya, lewat celah keamanan.
- Reputasi situs (site reputation policy): konten pihak ketiga yang di-publish di situs lain terutama untuk menumpang reputasi situs tersebut, pola yang juga disebut parasite SEO.
### Apakah website bisnis kamu bisa kena dampaknya?
Dampak yang perlu kamu waspadai muncul ketika website kamu sendiri dipakai sebagai tempat menaruh halaman spam. Salah satu celah yang disebut Google adalah WordPress, Joomla! atau Drupal versi lama yang tidak aman.
### Cara melindungi website: cek halaman asing, akun admin, plugin, dan Search Console
Cek empat hal berikut, dan semuanya bisa kamu kerjakan sendiri:
- Halaman asing: cari site:domainkamu.com di Google, lalu perhatikan judul yang tidak pernah kamu tulis, terutama yang memakai kata streaming, slot, atau bahasa asing.
- Akun admin: hapus akun yang sudah tidak dipakai dan ganti password yang lemah.
- Plugin dan tema: update semuanya, dan hapus yang tidak aktif. Kalau website kamu memakai WordPress, risiko plugin saya bahas di kekurangan WordPress.
- Search Console: buka laporan Masalah keamanan (Security issues) dan Tindakan manual (Manual actions), yang menampilkan temuan kalau Google menilai situs kamu diretas atau peninjau di Google menilai halaman kamu melanggar kebijakan.
Untuk pengecekan teknis yang lebih lengkap, kamu bisa memakai checklist audit SEO teknis, dan untuk memantau posisi setelah ada perubahan, ada catatan tentang cara saya mengecek ranking setelah rilis.
### Cara melaporkan halaman spam ke Google
Google punya halaman untuk melaporkan masalah kualitas yang mengarahkan kamu ke form terpisah untuk halaman spam, malware, dan phishing.
### Pertanyaan yang sering ditanyakan
#### Apa itu parasite SEO?
Parasite SEO adalah sebutan umum untuk konten yang ditaruh di situs lain yang sudah punya reputasi supaya konten itu ikut naik di Google. Di halaman kebijakan spamnya, Google memakai nama kebijakan reputasi situs dan tidak lagi memakai label lama “site reputation abuse”. Halaman yang sama juga mencatat perubahan khusus untuk Kawasan Ekonomi Eropa (EEA), jadi baca versi terbarunya kalau website kamu melayani pengunjung di sana.
#### Bagaimana cara mengetahui website kamu diretas atau melanggar kebijakan spam?
Buka dua laporan yang selalu tersedia di Search Console, yaitu Masalah keamanan (Security issues) dan Tindakan manual (Manual actions), setiap kali kamu menemukan judul asing di hasil site:. Selama tidak ada masalah, kedua laporan itu tidak berisi temuan. Kalau laporan Masalah keamanan berisi temuan, minta developer kamu memeriksa satu celah lain yang disebut di halaman bantuannya, yaitu direktori yang tidak aman di server.
#### Bagaimana cara melaporkan halaman spam ke Google?
Mulai dari halaman pelaporan masalah kualitas, lalu pilih form yang sesuai, karena Google memisahkan laporan untuk halaman spam, malware, dan phishing. Jangan sertakan data pribadi apa pun di laporan, karena Google meminta hal itu dan menjelaskan bahwa isi laporan bisa diteruskan ke pemilik situs yang kamu laporkan. Halaman kebijakan spam Google juga menautkan form laporan pengguna untuk kualitas pencarian, jadi kamu bisa masuk dari salah satu halaman itu.
#### Kenapa judul halaman spam terlihat berantakan?
Judul itu berisi deretan simbol, campuran bahasa, tanggal laga, dan kata kunci pencarian yang ditumpuk tanpa membentuk kalimat. Kamu bisa memakai ciri ini untuk mengenali spam sebelum mengeklik, yaitu judul yang diawali simbol seperti tanda seru dan tanda dolar, kata dari bahasa yang tidak cocok dengan negara pencarian, dan janji siaran langsung. Pada kasus 18 Oktober, ketiga ciri itu muncul sekaligus di satu judul.
### Penutup
Halaman spam di pencarian yang ramai berada di luar kendali kamu, sedangkan celah di website sendiri bisa kamu tutup. Cari site: dengan domain kamu di Google dan baca setiap judul yang muncul. Kalau ada judul asing dan kamu butuh bantuan menelusurinya, kirim URL website kamu lewat halaman jasa SEO, dan saya balas dalam 24 jam.
Terakhir dicek: 18 Oktober 2026.
---
## Cara membuat halaman jadwal dan hasil pertandingan yang ramah SEO dengan Next.js
URL: https://madebyaris.com/blog/halaman-jadwal-pertandingan-nextjs
Published: 2026-10-18. Updated: 2026-10-18.
Borneo FC memainkan laga debutnya di AFC Challenge League (ACGL) melawan Yangon United di Stadion Segiri, Samarinda, pada Minggu, 18 Oktober 2026 pukul 20.00 WITA atau 19.00 WIB, sesuai jadwal di website resmi klub. Kalau klub atau turnamen kamu membagikan jadwal hanya sebagai gambar di grup WhatsApp atau sebagai satu file PDF, Google tidak punya halaman untuk setiap pertandingan yang bisa diberi data terstruktur dan diperbarui dengan mudah.
### Jawaban singkat
Struktur yang ramah SEO cukup terdiri dari satu halaman daftar dan satu halaman untuk setiap pertandingan, dengan data yang diambil dari satu file supaya tidak ada dua versi jadwal. Setiap halaman pertandingan diberi JSON-LD SportsEvent, yaitu data terstruktur yang menjelaskan siapa bertanding, kapan, dan di mana. Setelah halaman live, hasilnya dicek di Rich Results Test dan Search Console.
### Hasil akhir: halaman jadwal yang bisa dibaca Google
Hasilnya berupa satu halaman daftar jadwal dan hasil, ditambah satu URL untuk setiap pertandingan dengan judul, tempat, dan waktu dalam bentuk teks biasa. Data yang dipakai adalah data contoh (fiktif), yaitu liga “Liga Contoh” dengan tim “Tim A FC” sampai “Tim H FC”. Saya membangun demo ini dengan bantuan AI coding agent, lalu hasilnya saya cek sendiri.
Di tutorial ini kita tidak membuat skor live yang berubah tanpa reload. Untuk kebutuhan itu, saya sudah menulis scoreboard sepak bola live dengan Next.js, dan halaman jadwal di sini bisa menjadi pasangannya.
### Yang kamu perlukan
Demo ini dibuat dengan Next.js 16.4.2 (App Router), React 19.3.0, dan Tailwind CSS v4, jadi kamu perlu Node.js yang bisa menjalankan versi Next.js itu, editor kode, dan sedikit pengalaman dengan App Router. Kalau App Router masih terasa baru, baca dulu App Router dalam praktik.
### Langkah 1: simpan data pertandingan di satu tempat
Semua halaman membaca data dari satu file JSON berisi daftar pertandingan, lewat fungsi kecil seperti getAllMatches() dan getMatchBySlug(), sehingga perubahan jadwal cukup ditulis sekali dan muncul di halaman daftar maupun di halaman pertandingan setelah build berikutnya. Halaman-halaman itu tidak memanggil API atau database.
Cuplikan data pertandingan (JSON), 2 dari 8 pertandingan:
```
[
{
"slug": "tim-a-fc-vs-tim-b-fc-pekan-1",
"matchday": 1,
"homeTeam": "Tim A FC",
"awayTeam": "Tim B FC",
"status": "finished",
"homeScore": 2,
"awayScore": 1,
"kickoff": "2026-10-12T15:30:00+07:00",
"venue": "Stadion Contoh Utara, Jakarta"
},
…
{
"slug": "tim-a-fc-vs-tim-c-fc-pekan-2",
"matchday": 2,
"homeTeam": "Tim A FC",
"awayTeam": "Tim C FC",
"status": "scheduled",
"kickoff": "2026-10-25T19:00:00+07:00",
"venue": "Stadion Contoh Utara, Jakarta"
},
]
```
Laga yang sudah selesai punya homeScore dan awayScore, sedangkan laga yang belum dimainkan tidak punya kolom skor, dan kickoff selalu membawa zona waktu (+07:00).
### Langkah 2: buat halaman daftar jadwal dan hasil
Halaman daftar ada di /jadwal dan mengelompokkan pertandingan per pekan, dengan judul “Pekan 1”, “Pekan 2”, dan seterusnya, lalu setiap kartu menampilkan “Selesai” beserta skornya atau “Akan main” beserta jam kick-off WIB. Semua isi ditulis sebagai teks HTML, sehingga setiap baris jadwal bisa dibaca, disalin, dan diperbarui tanpa membuat gambar baru. Di halaman yang sama, demo juga menaruh satu tag script berisi JSON-LD untuk kedelapan pertandingan. Google sendiri menyarankan markup event dipasang di halaman setiap event daripada di halaman yang berisi daftar jadwal, jadi markup yang penting ada di halaman pertandingan pada langkah berikutnya.
app/jadwal/page.tsx:
```
export default function JadwalPage() {
const matches = getAllMatches();
const byDay = groupMatchesByMatchday(matches);
const jsonLd = matches.map((m) => sportsEventJsonLd(m));
return (
<>
{/* … */}
```
### Langkah 3: buat satu halaman untuk setiap pertandingan
Halaman pertandingan memakai route dinamis /jadwal/[slug], misalnya /jadwal/tim-a-fc-vs-tim-b-fc-pekan-1, dan semua halamannya dibuat lebih dulu lewat generateStaticParams. Fungsi generateMetadata mengisi judul serta deskripsi dari data pertandingan itu sendiri, sehingga setiap URL punya judul yang berbeda. Cara mengatur metadata ini saya bahas lebih lengkap di metadata SEO di Next.js App Router.
app/jadwal/[slug]/page.tsx:
```
type PageProps = { params: Promise<{ slug: string }> };
export async function generateStaticParams() {
return getAllSlugs().map((slug) => ({ slug }));
}
export async function generateMetadata({
params,
}: PageProps): Promise {
const { slug } = await params;
const match = getMatchBySlug(slug);
if (!match) {
return { title: "Pertandingan tidak ditemukan" };
}
const title = matchTitle(match);
const description =
match.status === "finished"
? `Hasil ${title}: ${match.homeScore}-${match.awayScore}. Pekan ${match.matchday}, ${match.venue}.`
: `${title} pekan ${match.matchday}. Kick-off ${formatKickoffWIB(match.kickoff)} WIB di ${match.venue}.`;
return {
title,
description,
openGraph: {
title,
description,
locale: "id_ID",
type: "website",
},
};
}
```
### Langkah 4: tambahkan JSON-LD SportsEvent
JSON-LD dibuat oleh fungsi sportsEventJsonLd(match) lalu ditaruh di halaman sebagai tag script, mengikuti pola dari dokumentasi Next.js tentang JSON-LD, dan isinya memakai properti Event dari schema.org seperti nama, waktu mulai, lokasi, dan status.
lib/json-ld.ts:
```
import { siteUrl } from "./site-url";
// …
export function sportsEventJsonLd(match: Match) {
const name = `${match.homeTeam} vs ${match.awayTeam}`;
const url = siteUrl(`/jadwal/${match.slug}`);
const payload: Record = {
"@context": "https://schema.org",
"@type": "SportsEvent",
name,
description: `Pertandingan Liga Contoh pekan ${match.matchday}: ${name}`,
startDate: match.kickoff,
eventStatus: eventStatus(match),
eventAttendanceMode: eventAttendanceMode(),
location: {
"@type": "Place",
name: match.venue,
address: {
"@type": "PostalAddress",
addressCountry: "ID",
},
},
// … homeTeam, awayTeam, competitor …
url,
};
return payload;
}
```
Cara halaman pertandingan menampilkannya, di app/jadwal/[slug]/page.tsx:
```
const jsonLd = sportsEventJsonLd(match);
// …
return (
<>
```
Fungsi siteUrl membaca NEXT_PUBLIC_SITE_URL dan memakai https://demo.example.com kalau variabel itu kosong, jadi di website yang sudah live, isi variabel itu dengan domain website kamu sendiri.
Data terstruktur membantu Google memahami halaman, tetapi Google sendiri menulis bahwa mereka tidak menjamin data terstruktur akan muncul di hasil pencarian, dan tampilan khusus untuk event juga belum tercantum untuk Indonesia. Anggap JSON-LD sebagai cara membuat halaman lebih jelas bagi mesin pencari.
### Langkah 5: ubah status saat pertandingan ditunda atau dibatalkan
Di demo, status pertandingan hanya scheduled dan finished, dan keduanya tetap menjadi EventScheduled di JSON-LD, seperti terlihat di fungsi berikut.
lib/json-ld.ts:
```
function eventStatus(match: Match): string {
if (match.status === "finished") {
return "https://schema.org/EventScheduled";
}
return "https://schema.org/EventScheduled";
}
```
Untuk laga yang ditunda atau dibatalkan, tambahkan status itu di data, lalu petakan ke nilai yang dijelaskan di panduan Event dari Google berikut:
- Ditunda tanpa tanggal baru: EventPostponed, dengan startDate lama tetap dipakai sampai tanggal barunya diketahui.
- Ditunda dengan tanggal baru: EventRescheduled, dengan startDate diganti ke tanggal baru dan previousStartDate berisi tanggal lama (opsional).
- Dibatalkan: EventCancelled, dengan startDate dan lokasi tetap seperti sebelumnya.
### Langkah 6: cek hasilnya di Rich Results Test dan Search Console
Demo ini belum online, jadi screenshot berikut menunjukkan JSON-LD yang dihasilkan satu halaman pertandingan lewat view-source di browser. Setelah halaman kamu live, masukkan URL-nya ke Rich Results Test, lalu pantau di Search Console apakah halaman pertandingan sudah terindeks.
### Pertanyaan yang sering ditanyakan
#### Apakah schema SportsEvent membuat jadwal tampil khusus di Google?
Tidak ada jaminan, seperti dijelaskan di Langkah 4. Yang bisa kamu cek sendiri adalah apakah Google membaca markup-nya, yaitu dengan memasukkan URL halaman pertandingan ke Rich Results Test setelah halaman live, lalu memantau apakah halaman itu terindeks di Search Console. Kalau Rich Results Test menampilkan error, perbaiki dulu kolom yang diminta, karena halaman dengan markup yang rusak tidak membantu Google memahami pertandingan kamu.
#### Apa bedanya halaman jadwal dan halaman scoreboard live?
Daftar jadwal berisi pertandingan dan hasil akhirnya, yang di demo ini dibuat lebih dulu saat build, sedangkan scoreboard live memperbarui skor selama laga berlangsung tanpa reload. Karena itu, halaman jadwal cocok sebagai halaman yang dicari lewat Google, sementara scoreboard cocok dibuka saat laga sedang berjalan. Kamu bisa menautkan scoreboard dari halaman pertandingan yang sedang berlangsung, sehingga pengunjung dari Google langsung menemukan skor terbaru.
#### Bagaimana cara menandai pertandingan yang ditunda?
Pakai EventPostponed kalau tanggal barunya belum ada, lalu ganti ke EventRescheduled setelah tanggalnya diketahui, sesuai daftar di Langkah 5. Status itu belum ada di demo, jadi kamu perlu menambahkannya sendiri di data dan di fungsi eventStatus. Tulis juga keterangan “ditunda” di kartu jadwal dan di halaman pertandingan, karena pengunjung membaca teks halaman, dan informasi di teks sebaiknya sama dengan isi markup.
#### Apakah halaman jadwal perlu satu URL untuk setiap pertandingan?
Perlu, kalau kamu memakai data terstruktur Event, karena panduan Google meminta setiap event punya halaman sendiri dengan markup di URL itu. Di demo, URL itu dibentuk dari slug yang memuat nama tim dan pekan, misalnya /jadwal/tim-a-fc-vs-tim-b-fc-pekan-1, sehingga alamatnya bisa dibaca orang. Pertahankan slug yang sama setelah laga selesai, supaya link yang sudah dibagikan tetap mengarah ke halaman hasil pertandingan.
### Penutup
Jadwal yang bisa dibaca Google dimulai dari data teks di satu sumber dan satu URL untuk setiap pertandingan. Buka jadwal klub atau turnamen kamu dan cek apakah jadwal itu masih berupa gambar. Kalau kamu ingin halaman seperti ini dibuatkan, kirim link jadwal yang sekarang lewat jasa pembuatan website Next.js, dan saya balas dalam 24 jam. Kamu juga bisa melihat dulu layanan Next.js development saya.
Terakhir dicek: 18 Oktober 2026.
---
## Kekurangan WordPress untuk bisnis kamu
URL: https://madebyaris.com/blog/kekurangan-wordpress
Published: 2026-10-18. Updated: 2026-10-25.
Sebagai pemilik bisnis atau yang pegang website di tim, kamu melihat situsnya lambat dibuka di HP, plugin-nya saling bentrok, dan update mulai terasa berisiko. Banyak kekurangan seperti itu bisa diperbaiki tanpa pindah platform. Sebagian lainnya struktural. Masalah itu datang dari bentuk situsnya, jadi tetap muncul walau tema, plugin, dan hosting sudah dibereskan berkali-kali.
Saya mengerjakan situs WordPress, headless, dan build custom di stack lain. Kalau situs kamu cukup diperbaiki, saya akan bilang begitu.
### Jawaban singkat
Kekurangan WordPress yang bisa diperbaiki tanpa pindah:
- Lambat dibuka di HP
- Plugin bentrok setelah update
- Celah keamanan dari plugin dan akses admin
- Tema atau page builder yang berat
- SEO teknis yang tidak pernah dicek
Kekurangan yang sifatnya struktural:
- Situs mulai berubah jadi aplikasi
- Logika bisnis yang tidak cocok jadi tumpukan plugin
- Satu konten harus tampil di website dan aplikasi
- Halaman marketing harus seragam dengan produk
Kalau masalah kamu ada di daftar pertama, tetap di WordPress dan perbaiki. Kalau ada di daftar kedua, mulai pertimbangkan headless atau build baru.
### Kelebihan WordPress yang masih relevan
Ini yang masih dikerjakan WordPress dengan baik:
- Editor bisa publish sendiri. Tim konten menulis dan menerbitkan di wp-admin tanpa menunggu developer.
- Block editor. Di tema yang dibangun dengan benar, editor bisa mengubah halaman lewat blocks tanpa menyentuh kode.
- Plugin untuk pekerjaan umum. Form, dasar SEO, membership, dan toko online sudah ada plugin-nya. Kalau plugin yang dirawat dengan baik sudah mengerjakan tugasnya, saya sebut namanya dan tidak menulis ulang.
- WooCommerce untuk toko (bahasa Inggris). Mary Jardin, salah satu proyek saya, berjalan di WordPress dan WooCommerce.
- Pengaturan SEO per halaman. Title dan description tiap halaman diatur dari wp-admin lewat Rank Math.
Blog yang sedang kamu baca ini juga ditulis di WordPress, lalu ditampilkan oleh front end terpisah.
### Kekurangan WordPress yang bisa diperbaiki tanpa pindah
Lima keluhan berikut biasanya bisa dibereskan di dalam WordPress, kecuali kalau page builder itu sendiri yang jadi batasnya.
#### Lambat dibuka di HP
Misalnya kamu membuka situs sendiri dari HP, dan halaman utamanya lama baru muncul.
Cek dulu angka HP di PageSpeed Insights dan laporan Core Web Vitals di Google Search Console. Batas baik menurut Google, pada persentil ke-75 dari pemuatan halaman: LCP paling lama 2,5 detik, INP paling lama 200 milidetik, dan CLS paling tinggi 0,1.
Penyebabnya biasanya satu atau dua dari ini:
- Hosting lambat mengirim byte pertama. Kalau server-nya lambat, perbaikan apa pun di halaman tidak akan menolong.
- Plugin memuat script dan style di setiap halaman, termasuk halaman yang tidak memakainya.
- Foto ukuran penuh dikirim tanpa format modern atau ukuran yang pas dengan layar.
- Database menggembung oleh revisi bertahun-tahun dan sisa opsi dari plugin lama.
- Tidak ada page cache, jadi setiap pengunjung memicu PHP dan query database.
- Page builder seperti Elementor menumpuk elemen bersarang dan CSS tambahan.
Perbaikannya: ukur halaman utama, cari penyebab yang paling memperlambat, perbaiki di staging, lalu bandingkan angka sebelum dan sesudah. Menambah satu plugin cache lagi jarang cukup. Cara saya mengerjakannya ada di halaman perbaikan kecepatan WordPress (bahasa Inggris).
Batasnya: kalau situsnya memang perlu dibangun ulang, perbaikan kecepatan hanya menunda.
#### Plugin bentrok setelah update
Misalnya kamu meng-update satu plugin, lalu form kontak berhenti mengirim pesan.
Penyebabnya: setiap fitur baru berarti plugin baru, sampai ada yang tumpang tindih dan ada yang tidak dirawat lagi.
Cek dulu plugin mana yang memicunya. Di staging, nonaktifkan semua plugin, lalu aktifkan lagi satu per satu sampai masalahnya muncul.
Perbaikannya: hapus plugin yang tidak dipakai, dobel, atau ditinggal pembuatnya. Coba setiap update di staging dulu, dan tes plugin yang penting sebelum live.
Kalau beberapa plugin generik dipaksa mengerjakan satu tugas, satu plugin custom bisa menggantikan semuanya. Saya membuat plugin seperti itu (bahasa Inggris), dari integrasi API sampai layar admin custom.
#### Celah keamanan dari plugin dan akses admin
Misalnya kamu membuka daftar pengguna di wp-admin dan menemukan akun admin milik developer lama.
Penyebabnya: plugin yang ketinggalan update dan login admin yang lemah adalah jalan masuk yang paling umum ke situs WordPress. Dua-duanya bisa ditutup tanpa pindah platform:
- Update core, tema, dan plugin secara terjadwal. Hapus yang tidak dipakai.
- Tinjau akun admin. Setiap orang hanya dapat role yang dia butuhkan.
- Aktifkan two-factor login untuk akun admin.
- Matikan fitur edit file di dalam wp-admin, lewat baris DISALLOW_FILE_EDIT di wp-config.php.
- Siapkan backup di luar server, lalu tes restore-nya.
#### Tema atau page builder yang berat
Misalnya situs kamu dibangun dengan Elementor atau Divi, dan halamannya tetap berat di HP walau cache sudah terpasang.
Perbaikannya: masalah kecepatan dan plugin-nya tetap bisa saya perbaiki. Saya pangkas widget dan script yang tidak dipakai, bereskan gambar dan cache, lalu setel pengaturan Elementor. Kalau builder itu sendiri yang jadi hambatan, saya kasih tahu.
Untuk build baru, saya biasanya menyarankan block theme. Page builder menambah banyak kode di front end dan tidak ikut terbawa kalau nanti kamu pindah ke headless. Pilihan lain adalah tema custom dari desain kamu, yang bisa diedit lewat blocks dan tetap ringan di HP. Detailnya ada di layanan WordPress saya (bahasa Inggris).
#### SEO teknis yang tidak pernah dicek
Misalnya situs kamu baru selesai di-redesign, dan beberapa URL lama sekarang membuka halaman 404.
Gejalanya: Rank Math terpasang, tapi pengaturannya tidak pernah disentuh sejak hari pertama. Redirect untuk URL lama hilang. Schema rusak dan tidak ada yang sadar. Penyebabnya ada di pengaturan.
Cek dulu Settings > Reading di wp-admin. Kalau kotak “Discourage search engines from indexing this site” tercentang, WordPress meminta mesin pencari tidak mengindeks situs kamu.
Perbaikannya: cek setting Rank Math per jenis halaman, buka laporan di Search Console, lalu tes halaman penting dengan Rich Results Test. Pasang redirect 301 dari URL lama ke halaman baru yang isinya paling mirip. Jangan arahkan semuanya ke halaman depan, karena Google bisa menganggapnya soft 404. Semuanya bisa dikerjakan tanpa pindah platform.
### Kekurangan WordPress yang sifatnya struktural
WordPress dengan tema klasik dirancang untuk halaman dan post. Begitu situs mulai menjadi aplikasi, perbaikan di tema tidak lagi sepadan dengan biayanya. Tandanya: performa dan SEO teknis sudah digarap, tapi hasilnya tetap mentok karena arsitektur tema atau builder.
#### Situs mulai berubah jadi aplikasi
Misalnya kamu ingin pelanggan bisa login untuk melihat pesanan mereka, atau mengisi form bertingkat sebelum melihat harga.
Gejalanya: tema klasik makin sulit diurus setiap kali ada fitur baru. Penyebabnya: area login, dashboard untuk pelanggan, alur bertingkat, filter yang kompleks, harga interaktif, dan komponen yang dipakai berulang di banyak halaman adalah ciri aplikasi. Plugin mana pun yang kamu pilih, hasilnya sama, karena situsnya sudah berbentuk aplikasi.
Saran saya: front end terpisah mulai masuk akal, tapi satu fitur saja belum otomatis berarti pindah.
#### Logika bisnis yang tidak cocok jadi tumpukan plugin
Misalnya harga di toko kamu berbeda untuk setiap pelanggan grosir, dan aturannya tersebar di beberapa plugin.
Gejalanya: setiap perubahan kecil merusak bagian lain, dan tidak ada tes yang menangkapnya.
Cek dulu: kalau satu plugin custom cukup untuk tugas itu, masalahnya masih bisa diperbaiki di WordPress.
Saran saya: harga khusus per pelanggan, sistem internal, logika CRM, atau stok barang lebih masuk akal sebagai kode aplikasi. Di kode aplikasi, logika itu bisa diberi tes, dan developer berikutnya bisa membacanya. Salah satu jalurnya Laravel, stack yang saya pakai untuk aplikasi PHP. Kalau logika itu sudah berjalan di aplikasi PHP lama, modernisasi ke Laravel (bahasa Inggris) bisa jalan bertahap. Bagian demi bagian dipindah, dan aplikasi lama tetap melayani pengguna selama prosesnya.
#### Satu konten untuk website dan aplikasi
Misalnya kamu punya aplikasi mobile, dan tim menyalin info produk dari wp-admin ke aplikasi itu secara manual.
Penyebabnya: tema klasik menampilkan konten hanya di website, jadi aplikasi tidak bisa mengambil konten dari tema itu.
Saran saya: konten dikirim lewat REST API atau GraphQL, dan tampilannya dibangun terpisah. WordPress tetap bisa jadi tempat editor menulis, tapi tema klasiknya tidak dipakai lagi. Blog ini bekerja seperti itu: tulisan yang di-publish di wp-admin sudah tampil di situs dalam hitungan detik. Jalur ini tetap proyek sungguhan: model konten, kontrak API, preview, redirect, dan siapa yang merawat kedua sisi.
#### Halaman marketing harus seragam dengan produk
Misalnya tim produk merilis tampilan baru di aplikasi, dan halaman harga di website kamu masih memakai tombol dan warna lama.
Penyebabnya: halaman marketing harus memakai design system yang sama dengan produk, dan tema klasik menyulitkan itu di setiap rilis.
Cek dulu apakah halaman marketing harus mengikuti UI produk yang sudah ada. Kalau tidak, tema custom dari desain kamu masih cukup.
Saran saya: kalau harus, bangun front end terpisah. Tim produk butuh front end yang bisa dites dan di-deploy seperti aplikasi, sementara tim konten tetap ingin publish tanpa menunggu.
### Pilihan di antara bertahan dan pindah total
Pindah tidak selalu berarti membuang semuanya. Ada empat jalur, dari yang paling kecil:
- Bertahan dan perbaiki. Untuk lima masalah di bagian perbaikan di atas. Cocok untuk situs konten yang masalahnya ada di pengaturan.
- Headless. Dengan headless WordPress (bahasa Inggris), editor tetap menulis di wp-admin, sementara front end terpisah merender halaman. Cocok kalau tim konten sebaiknya tetap di WordPress, tapi Core Web Vitals mulai merugikan traffic atau penjualan. Kurang cocok untuk situs yang bergantung pada Elementor, Divi, atau banyak plugin front end, karena tampilan dari builder dan plugin itu tidak ikut ke front end baru.
- Build penuh. Situs dibangun ulang sebagai aplikasi, termasuk login dan API-nya sendiri. Konten bisa pindah ke CMS lain atau admin custom. Cocok kalau tampilan produk lebih penting daripada admin CMS. Kurang cocok kalau template jadi sudah mengerjakan yang kamu butuhkan. Jalurnya lewat pengembangan Next.js (bahasa Inggris).
- Laravel untuk bagian aplikasinya. Kalau yang berat adalah logika bisnis, bagian itu bisa jadi aplikasi Laravel, dan situs kontennya tidak harus ikut pindah.
### Kapan sebaiknya tetap di WordPress?
Saya menyarankan tetap di WordPress kalau sebagian besar kondisi ini benar:
- Isi situs kamu sebagian besar halaman dan post, tanpa alur aplikasi yang rumit.
- Editor sudah nyaman menulis di wp-admin.
- Plugin yang ada sudah cukup, tanpa tambalan di atas tambalan.
- Kecepatannya sudah cukup untuk target bisnis setelah cache dan pembersihan.
- Belum ada anggaran atau orang yang akan merawat situs baru setelah launch.
Kalau itu gambaran situs kamu, tetap di WordPress. Perbaiki kecepatan atau plugin yang mengganggu, lalu nilai lagi saat situs kamu memang butuh front end aplikasi.
### Tanda-tanda kamu perlu pindah dari WordPress
Kecepatan dan plugin bisa diperbaiki, jadi keduanya belum jadi alasan pindah. Tanda yang perlu kamu perhatikan:
- Lima perbaikan di atas sudah dikerjakan, tapi area login, dashboard, atau alur bertingkat masih sulit dibangun di tema.
- Setiap kebutuhan bisnis baru berakhir jadi plugin baru, padahal tempatnya di kode aplikasi.
- Konten harus tampil di website dan aplikasi, atau halaman marketing harus berbagi design system dengan produk.
Langkah pindahnya sendiri, dari risiko sampai pertanyaan untuk vendor, sudah saya tulis di checklist sebelum migrasi ke Next.js.
### Pertanyaan yang sering ditanyakan
#### Apakah WordPress aman untuk website bisnis?
Aman kalau dirawat dengan disiplin. Artinya update terjadwal, plugin sedikit dan masih dirawat pembuatnya, dan akses admin hanya untuk orang yang butuh. Tambahkan two-factor login untuk admin dan backup di luar server yang restore-nya sudah dites.
#### Apakah WordPress masih relevan untuk bisnis?
Masih, untuk situs yang isinya konten dan diurus tim editorial di wp-admin. Batasnya muncul saat situs berubah jadi aplikasi, misalnya dengan area login, dashboard pelanggan, atau logika bisnis yang berat. Untuk kebutuhan seperti itu, bagian aplikasinya bisa dibangun terpisah.
#### Haruskah pindah dari WordPress?
Belum tentu. Perbaiki dulu kecepatan, plugin, keamanan, tema, dan pengaturan SEO di dalam WordPress. Pindah baru masuk akal kalau situs kamu sudah berbentuk aplikasi dan masalahnya tetap kembali setelah semua itu beres.
#### WordPress atau website custom, mana yang lebih baik?
Untuk situs konten yang diurus editor, WordPress biasanya sudah cukup. Untuk produk berbentuk aplikasi atau logika bisnis yang berat, build custom dengan Next.js atau Laravel lebih masuk akal.
#### Apa bedanya headless WordPress dengan pindah total?
Headless mempertahankan wp-admin dan konten di WordPress, lalu hanya mengganti front end. Pindah total mengganti CMS-nya juga. Headless kurang cocok untuk situs yang bergantung pada page builder seperti Elementor atau Divi, karena tampilannya tidak ikut terbawa.
#### Apakah ranking Google turun kalau pindah dari WordPress?
Seharusnya tidak, asalkan setiap URL lama dipertahankan atau dialihkan dengan redirect 301 sebelum launch. Title dan description juga dibawa, sitemap dibuat ulang, dan Search Console dipantau setelah launch untuk mencari halaman 404. Tanpa peta redirect, ranking dan backlink bisa goyah.
### Minta saya cek situs WordPress kamu
Lima kekurangan pertama, dari situs yang lambat sampai SEO teknis yang tidak pernah dicek, bisa dibereskan di dalam WordPress, sedangkan empat kekurangan struktural adalah tanda bahwa bagian aplikasi di situs kamu perlu dibangun di luar tema klasik.
Kirim URL situs kamu dan satu hal yang paling mengganggu: lambat, plugin bermasalah, atau fitur yang tidak bisa ditangani WordPress. Kirim lewat form kontak dan saya balas dalam 24 jam, dengan jawaban yang jelas: cukup diperbaiki, atau memang sudah waktunya pindah.
Kirim URL website kamu
---
## Cara membuat scoreboard sepak bola live dengan Next.js
URL: https://madebyaris.com/blog/cara-membuat-scoreboard
Published: 2026-10-14. Updated: 2026-10-25.
Timnas putri Indonesia bermain imbang 0-0 melawan Yordania di Stadion Aqaba Development, Aqaba, pada 13 Oktober 2026, seperti dilaporkan ANTARA. Kalau laga seperti itu ditayangkan di nonton bareng, turnamen kampung, atau acara kantor, skor di layar sebaiknya langsung berubah begitu ada gol, tanpa ada yang menekan tombol reload.
### Hasil akhir: scoreboard yang update tanpa reload
Di akhir tulisan ini, kamu punya dua halaman. Halaman utama menampilkan skor besar untuk layar TV atau proyektor. Halaman admin berisi tombol untuk menambah atau mengurangi gol, dan perubahan dari admin muncul di layar dalam hitungan detik.
Data contoh di tulisan ini adalah final FIFA ASEAN Cup 2026 pada 5 Oktober 2026: Indonesia vs Thailand 2-2 (4-2 adu penalti), seperti dilaporkan tirto.id. Skor ini hanya data contoh, jadi kamu bisa menggantinya dengan pertandingan apa pun.
### Kapan cukup Excel atau OBS, kapan perlu web app
Tidak semua acara butuh aplikasi web. Pilih alat yang paling sederhana untuk kebutuhan kamu.
Kebutuhan | Alat yang cukup |
Satu layar, satu operator di laptop yang sama | Excel, PowerPoint, atau papan skor fisik |
Skor tampil di siaran live streaming | Overlay di software siaran seperti OBS |
Skor diubah dari HP, tampil di layar lain | Web app seperti di tulisan ini |
Banyak pertandingan, akun panitia, riwayat skor | Web app dengan database dan login |
Di sini saya fokus ke baris ketiga. Baris keempat butuh database dan login, dan dibahas di bagian akhir.
### Yang kamu perlukan
- Node.js terpasang di komputer kamu.
- Dasar React: komponen, state, dan useEffect.
- Editor kode dan terminal.
Kode di tulisan ini dites pada 7 Oktober 2026 memakai Next.js 16.4.0 dan Node.js 20.19.2.
### Langkah 1: buat project Next.js
Jalankan perintah berikut di terminal. Flag-nya menjawab pertanyaan setup: TypeScript, App Router, tanpa folder src.
```
npx create-next-app@latest scoreboard --ts --app --eslint --no-tailwind --no-src-dir --import-alias "@/*" --use-npm --yes
cd scoreboard
```
Biarkan app/page.tsx bawaan dulu. Isinya kamu ganti di langkah 4. Di app/layout.tsx, ganti lang="en" menjadi lang="id", supaya browser dan pembaca layar tahu bahasa halamannya.
### Langkah 2: simpan skor di server
Buat file lib/score-store.ts. File ini menyimpan skor di memori server dan menyediakan fungsi untuk membaca dan mengubahnya.
```
export type Score = {
home: string;
away: string;
homeGoals: number;
awayGoals: number;
homePens: number | null;
awayPens: number | null;
status: string;
updatedAt: string;
};
// Data contoh: final FIFA ASEAN Cup 2026 menurut tirto.id.
const initialScore: Score = {
home: "Indonesia",
away: "Thailand",
homeGoals: 2,
awayGoals: 2,
homePens: 4,
awayPens: 2,
status: "Selesai (adu penalti)",
updatedAt: new Date().toISOString(),
};
// Disimpan di memori server. Cukup untuk belajar di komputer sendiri.
const globalStore = globalThis as unknown as { score?: Score };
export function getScore(): Score {
if (!globalStore.score) globalStore.score = { ...initialScore };
return globalStore.score;
}
export function updateScore(changes: Partial): Score {
const next = { ...getScore(), ...changes, updatedAt: new Date().toISOString() };
globalStore.score = next;
return next;
}
```
Penyimpanan di memori cukup untuk belajar di komputer sendiri. Skor kembali ke data awal setiap kali server dinyalakan ulang.
### Langkah 3: buat API skor
Buat file app/api/score/route.ts. GET mengirim skor terbaru. POST mengubah skor, tetapi hanya kalau token admin cocok dan datanya valid.
```
import { getScore, updateScore, type Score } from "@/lib/score-store";
export async function GET() {
return Response.json(getScore(), {
headers: { "Cache-Control": "no-store" },
});
}
const numberFields = ["homeGoals", "awayGoals", "homePens", "awayPens"] as const;
function isCount(value: unknown) {
return Number.isInteger(value) && (value as number) >= 0;
}
export async function POST(request: Request) {
const token = request.headers.get("x-admin-token");
if (!process.env.ADMIN_TOKEN || token !== process.env.ADMIN_TOKEN) {
return Response.json({ error: "Tidak diizinkan" }, { status: 401 });
}
let body: Record;
try {
body = await request.json();
} catch {
return Response.json({ error: "Data tidak valid" }, { status: 400 });
}
if (typeof body !== "object" || body === null || Array.isArray(body)) {
return Response.json({ error: "Data tidak valid" }, { status: 400 });
}
const changes: Partial = {};
for (const field of numberFields) {
if (!(field in body)) continue;
const value = body[field];
const pensField = field === "homePens" || field === "awayPens";
if (isCount(value) || (pensField && value === null)) {
changes[field] = value as number;
} else {
return Response.json({ error: `${field} harus angka 0 atau lebih` }, { status: 400 });
}
}
if ("status" in body) {
if (typeof body.status !== "string") {
return Response.json({ error: "status harus teks" }, { status: 400 });
}
changes.status = body.status.slice(0, 60);
}
return Response.json(updateScore(changes));
}
```
Simpan token di file .env.local, misalnya ADMIN_TOKEN=ganti-dengan-token-panjang. Jangan masukkan file ini ke Git. API hanya menerima gol dan penalti berupa angka 0 atau lebih, plus status berupa teks. Data lain ditolak dengan kode 400, dan nama tim tidak bisa diganti lewat API.
### Langkah 4: halaman skor yang update sendiri
Buat file app/scoreboard.tsx. Komponen ini mengambil skor dari API saat halaman dibuka, lalu mengulanginya setiap 2 detik.
```
"use client";
import { useEffect, useState } from "react";
import type { Score } from "@/lib/score-store";
export default function Scoreboard() {
const [score, setScore] = useState(null);
useEffect(() => {
async function load() {
const res = await fetch("/api/score", { cache: "no-store" });
if (res.ok) setScore(await res.json());
}
load();
const timer = setInterval(load, 2000);
return () => clearInterval(timer);
}, []);
if (!score) return Memuat skor...;
const hasPens = score.homePens !== null && score.awayPens !== null;
return (
);
}
```
Halaman admin ini sengaja sederhana. Siapa pun yang tahu token bisa mengubah skor, jadi pakai token yang panjang dan ganti setelah acara.
### Langkah 6: tampilan untuk layar besar
Ganti isi app/globals.css dengan gaya berikut. Ukuran huruf memakai clamp, jadi skor tetap terbaca di HP maupun TV.
```
body { margin: 0; font-family: system-ui, sans-serif; background: #0b1220; color: #fff; }
.board { min-height: 100vh; display: grid; place-content: center; text-align: center; gap: 1rem; }
.teams { display: flex; gap: 2rem; align-items: center; font-size: clamp(1.5rem, 5vw, 3rem); }
.teams strong { font-size: clamp(3rem, 12vw, 8rem); }
.status, .pens { font-size: clamp(1rem, 3vw, 1.75rem); opacity: 0.85; }
.admin { max-width: 420px; margin: 2rem auto; display: grid; gap: 0.75rem; }
.admin .row { display: flex; gap: 0.5rem; align-items: center; justify-content: space-between; }
.admin button, .admin input { font-size: 1rem; padding: 0.5rem 1rem; }
```
Jalankan npm run dev, buka http://localhost:3000 di satu tab dan http://localhost:3000/admin di tab lain. Ubah skor di admin, lalu lihat layar skor berubah sendiri. Untuk acara, jalankan npm run build lalu npm start, supaya yang berjalan adalah versi produksi.
### Sebelum online: skor perlu tempat simpan bersama
Di komputer sendiri, satu server menyimpan skor di memori. Di hosting serverless seperti Vercel, permintaan bisa dilayani oleh beberapa instance berbeda, dan memori tidak dibagi antar-instance. Akibatnya, layar skor bisa membaca angka lama.
Untuk versi online, ganti isi getScore dan updateScore dengan penyimpanan bersama, misalnya database atau key-value store. Bagian lain dari kode tidak perlu berubah. Di sini saya berhenti di versi lokal, jadi langkah itu tidak dibahas.
### Masalah umum dan solusinya
Masalah | Sebab | Solusi |
Skor terlambat sampai 2 detik | Interval polling | Perkecil interval, atau pakai server-sent events |
Dua admin mengubah skor bersamaan | Admin membaca lalu menulis angka | Untuk acara kecil, tunjuk satu operator |
Skor kembali ke awal | Server dinyalakan ulang | Pakai penyimpanan bersama seperti di bagian sebelumnya |
Token salah terus | .env.local belum dibaca | Nyalakan ulang npm run dev setelah mengubah file |
### Kapan perlu developer
Scoreboard ini cukup untuk satu pertandingan dengan satu operator. Kalau kamu butuh banyak pertandingan sekaligus, akun panitia, riwayat skor, atau tampilan untuk sponsor, kamu butuh aplikasi web yang dirancang dari awal.
Panitia nonton bareng, misalnya, bisa saja menayangkan beberapa laga timnas dalam sepekan seperti laga di awal tulisan, dan di situ kebutuhan seperti riwayat skor mulai terasa.
### Pertanyaan soal membuat scoreboard
#### Bisakah membuat scoreboard tanpa coding?
Bisa, karena Excel, PowerPoint, papan skor fisik, atau overlay di software siaran sudah cukup untuk banyak acara. Pilihan ini cocok kalau skor diubah dan ditampilkan dari satu komputer yang sama. Kamu baru perlu kode seperti di tulisan ini kalau skor harus diubah dari HP dan tampil di layar lain tanpa reload.
#### Bagaimana menampilkan scoreboard ini di TV?
Buka alamat halaman skor di browser pada laptop yang tersambung ke TV atau proyektor, lalu pakai mode layar penuh. Ukuran huruf di langkah 6 menyesuaikan lebar layar, jadi skor tetap besar di layar lebar. Kalau server berjalan di laptop, HP admin harus memakai Wi-Fi yang sama dan membuka alamat “Network” yang dicetak di terminal.
#### Kenapa skor di layar terlambat beberapa detik?
Layar skor mengambil data baru setiap 2 detik, jadi perubahan dari admin bisa muncul sampai 2 detik kemudian. Kamu bisa memperkecil interval di setInterval, tapi permintaan ke server jadi lebih banyak. Untuk acara besar dengan banyak layar yang terbuka bersamaan, server-sent events atau layanan real-time lebih cocok daripada polling setiap beberapa detik.
### Langkah berikutnya
Alat yang paling sederhana biasanya sudah cukup, dan enam langkah di atas baru diperlukan kalau skor harus diubah dari HP lalu tampil di layar lain. Sebelum hari pertandingan, jalankan scoreboard ini di komputer sendiri dan coba ubah skornya dari HP lewat Wi-Fi yang sama.
Untuk mengenal framework yang dipakai, baca penjelasan Next.js untuk pemilik bisnis . Kalau kamu butuh aplikasi web untuk turnamen atau komunitas, lihat jasa pembuatan website Next.js saya, atau baca dulu tentang layanan Next.js development.
Kirim kebutuhan acara kamu lewat halaman kontak. Saya balas dalam 24 jam.
Terakhir dicek: 14 Oktober 2026.
---
## How to hire a web developer: questions to ask before you sign
URL: https://madebyaris.com/blog/how-to-hire-a-web-developer
Published: 2026-10-13. Updated: 2026-10-14.
You run a business and you are about to hire a web developer. You fear a contract that leaves you without the code, the logins or a finished site. To hire a web developer safely, write a short brief and check work you can open.
### Quick answer: 6 steps
- Write a one-page brief: the goal, the pages or features, the deadline and who updates the site later.
- Choose the type of hire: a freelancer, an agency or an in-house developer.
- Send the same brief to two or three candidates, so the answers are comparable.
- Check work you can open: live sites, code, or a small paid test.
- Ask the 10 questions below and get the answers in writing.
- Sign only when the proposal names the scope, milestones, ownership and handover.
### Write the brief first
I am on the receiving end of these briefs. I have worked in web development since 2013 and run my own practice since 2015. A clear brief is the fastest way to get quotes you can compare.
Put these items in the brief:
- The goal of the site and who will use it.
- The pages or features you must have at launch, and the ones that can wait.
- Who writes the content, and when it will be ready.
- Other systems the site must connect to, such as payments, a CRM or email.
- The deadline, and any date that cannot move.
- Who will update and maintain the site after launch.
- The accounts you already have, such as the domain and hosting, and whose name they are in.
### Freelancer, agency or in-house
Each option fits a different situation. I am one independent developer, so read this table with that in mind.
Option | Fits when | Watch for |
Freelancer | One clear project, and you want to talk to the person who writes the code | One person: ask who covers holidays or illness |
Agency | You need design, content and development at the same time | Ask who writes the code, and how many people handle your project |
In-house | You have continuous product work for years | Hiring time, salary and someone to manage the work |
### Where to find developers
Start with referrals from businesses you know. Then look at developer portfolio sites, agency case studies and freelance marketplaces. Wherever you find a candidate, send the same brief and use the same checks.
### How to check skills
- Open live sites the candidate built. Use them on your phone and on a laptop.
- Ask for a code sample or a walkthrough of a repository, if someone on your side can read code.
- For a larger project, pay for a small test task with a clear output.
- Ask for one reference you can call.
For a Next.js project, see the screening checklist in hire a Next.js developer: what good looks like in 2026.
### 10 questions to ask before you sign
These questions cover scope, ownership and handover. Ask for the answers in writing, in the proposal or the contract.
# | Question | A good answer names |
1 | What is in the scope, and what is out of scope? | A list of pages or features, and a list of exclusions |
2 | What happens if I ask for something new during the project? | A change request with its own price and date |
3 | How many rounds of changes does each milestone include? | A number per milestone |
4 | Who owns the code, the design files and the content after I pay? | You, after each paid milestone or at final payment |
5 | Are the domain, hosting and other accounts in my name? | Yes, or a date when they move to you |
6 | Which paid themes, plugins or services does the site need? | Each item, its cost owner and whose name the licence is in |
7 | What do I receive at the end? | The code repository, all logins and short documentation |
8 | Who can update the site after launch, and how? | Your team, with a short guide or training |
9 | What support is included after launch, and for how long? | A period, what it covers and what it does not |
10 | How do we communicate, and how fast do you reply? | One channel and a reply time |
### Read the proposal and the milestones
A proposal should arrive before any code. I send a written plan with milestones and a quote before I write code. Use that as your test for any developer.
Check each milestone for three things:
- A result you can see, such as a page design or a working form.
- A date.
- A payment tied to that result.
The proposal should also list what is not included. For how fixed-price, hourly and retainer models compare, read what it costs to hire a Next.js developer.
### Contract basics
I am not a lawyer. For a large contract, ask a lawyer to read it. These are the points to look for:
- Ownership: see question 4.
- Confidentiality: an NDA, if the project is sensitive. I can sign one for sensitive projects.
- Payment: amounts tied to milestones, not to dates alone.
- Stopping: what you receive if either side ends the project early.
- Bugs after launch: how long the developer fixes defects at no extra cost.
### Red flags
- There is no written scope, only a call.
- You get a price before the developer has read your brief.
- The developer will not put the domain, hosting or code in your name.
- A large payment comes first, with no milestone behind it.
- The candidate cannot show work you can open.
- The candidate agrees to everything and asks no questions.
### Questions about hiring a web developer
#### How much does it cost to hire a web developer?
The cost depends on the scope, the type of hire and the pricing model you agree on. A quote is only useful when it rests on a written brief, so compare quotes on one brief. This post gives no rates, but the cost post above covers pricing models and what changes a quote.
#### Should I hire a freelancer or an agency?
Hire a freelancer when you have one clear project and want to talk to the person who writes the code. Hire an agency when you need design, content and development at the same time from one team. In both cases, ask who writes the code, then compare the written answers to the same 10 questions.
#### What should I send a developer first?
Send a one-page brief with the goal, the must-have pages or features, the deadline and the site owner after launch. Add links to sites you like and a list of the accounts you already own, such as the domain. A good developer replies with questions about the brief before giving a price.
### What to do next
If you have no brief yet, write one with the list above before you contact anyone. If you have quotes already, ask each developer the 10 questions and compare the written answers. If an answer on ownership or handover is vague, ask again before you pay a deposit. Then sign the proposal that answers all 10 clearly.
If you want me to read your brief, see my web development services or send it through the contact page. I reply within 24 hours and tell you plainly if I am the right fit.
---
## Website maintenance cost: what a monthly plan should cover
URL: https://madebyaris.com/blog/website-maintenance-cost
Published: 2026-10-13. Updated: 2026-11-08.
You pay for website maintenance every month. The invoice says “maintenance”, but you do not know what work was done. Here is what a plan should cover and what makes it cost more or less.
### Quick answer
Website maintenance cost depends on three things: the work the plan includes, how often it happens and how fast someone responds. A site with many plugins, frequent changes and a shop costs more to maintain than a small brochure site.
A good plan lists each task, its frequency and what is out of scope. If your plan only says “maintenance”, ask for that list before you compare prices.
This post gives no price ranges. A price without a task list cannot be compared.
### What a monthly plan should cover
The table below is a baseline for a typical business site. Your site may need more or fewer tasks.
Task | Frequency | What you should see in the report |
Core, theme and plugin updates | When released, or on a fixed day | List of updates and the date applied |
Backups | Daily or weekly, by change rate | Last backup date and where it is stored |
Restore test | Quarterly | Date of the last successful restore |
Uptime monitoring | Continuous | Downtime events and their length |
Security checks | Monthly | Scan result and any action taken |
Speed check | Monthly | PageSpeed Insights result with the date |
Search Console review | Monthly | New errors and what was fixed |
Broken links and forms | Monthly | Pages checked and form test result |
Small content edits | As agreed | Number of edits used this month |
### What drives the monthly cost
Six things move the price of a plan up or down. Ask about each one when you read a quote.
- Update load. More plugins and integrations mean more updates to test.
- Change rate. A site that adds pages every week needs more backups and more checks than a site that rarely changes.
- Site type. A shop with payments carries more risk than a brochure site.
- Response time. A promise to fix problems within hours costs more than a promise to fix them within days.
- Included work. Content edits, design changes and reports add hours.
- Hosting and licenses. Some plans include hosting or premium licenses, and some bill them separately.
Update load is easy to underestimate. The WordPress release archive lists a feature release on 19 August 2026. Three point releases followed, on 17 September, 22 September and 6 October 2026. The archive also says that only the latest release in that branch is actively maintained (checked 13 October 2026).
### Cost by site type
Different sites need different work. The table compares the main types without prices.
Site type | Main maintenance work | Cost pressure |
Brochure site | Updates, backups, uptime | Low, if plugins are few |
WooCommerce or other shop | Updates tested against checkout, payment checks, order backups | Higher, because errors cost sales |
Headless site (CMS plus separate front end) | Updates on two systems, build and deploy checks | Medium, with two codebases to watch |
Web app with logins | Dependency updates, database backups, security reviews | Higher, can be billed by hours |
I run a headless site myself: WordPress for content and Next.js on Vercel for the front end. If your site has the same setup, read headless WordPress with Next.js for how the two parts fit.
### Who does the work
Each option can work. The right choice depends on the time you have and the risk you can carry.
Option | Strength | Watch for |
Do it yourself | Lowest cash cost | Your time, and restore skills when something breaks |
Freelancer | Direct contact with the person doing the work | Cover when that person is away |
Agency | A team that can cover absences | Handoffs between people |
Hosting company plan | Updates and backups bundled with hosting | Narrow scope, may exclude content or code fixes |
For any option, ask who has access, where backups live and what happens if the contract ends. For developer rates, see cost to hire a Next.js developer.
### Costs that go missing from a quote
Some costs sit outside the monthly fee. Check these five before you sign.
- Emergency fixes outside the plan hours.
- Premium plugin or theme license renewals.
- Hosting upgrades when traffic grows.
- Recovery work after a hack, if the plan does not cover it.
- Extra hours when an update breaks a custom feature.
Ask for each item in writing: included, not included, or billed separately. Any of those three answers is fine, as long as it is written down.
### How to read a maintenance report
A monthly report is your proof that the work happened. It should match the task table in your plan, line by line.
Look for dates, not general words. “Updated plugins” tells you little. “Updated 4 plugins on 3 October, backup taken before the update” tells you what happened and when.
### Questions about website maintenance cost
#### Is website maintenance a monthly or a yearly cost?
It is usually both: a monthly or per-task plan fee, plus yearly renewals such as domain and licenses. When you budget, add the monthly fee and the yearly items to see the full cost of running the site. Ask your provider to show both kinds of cost in one list, so renewals do not surprise you.
#### Can I maintain my website myself?
Yes, if you can run updates, keep backups and restore the site when something breaks. The hardest part is the restore, so test it on a copy of the site before you rely on it. With payments or custom code, a failed update costs more, so paid help may cost less than the downtime.
#### What should a maintenance plan not include?
A plan should not hide new features or redesigns inside the monthly fee, because that makes the scope unclear. New pages, new functions and large design changes are projects, and they need their own quote and timeline. A clear plan states this limit in writing, so you know which requests fall outside the monthly work.
### Next steps
If your plan has no task list, ask for one. If it has a list, compare it with the table in this post.
If an item is missing, ask whether it is included, not included or billed separately. Then compare prices.
For help with a WordPress site, see my WordPress maintenance service or the wider WordPress services. For a Next.js or headless site, see Next.js development.
Send me your current task list through the contact page. I reply within 24 hours.
---
## Technical SEO audit checklist for Next.js and WordPress sites
URL: https://madebyaris.com/blog/technical-seo-audit-checklist
Published: 2026-10-13. Updated: 2026-10-24.
You manage a Next.js or WordPress site, and someone says it needs a technical SEO audit. A technical SEO audit checks whether Google can crawl, render, index and understand your pages.
You can run the 12 checks below yourself with Search Console, PageSpeed Insights and the Rich Results Test. An audit finds problems. It does not promise rankings.
### Quick answer: the 12 checks
# | Check | Tool | A pass looks like |
1 | Crawling is allowed | URL Inspection in Search Console | Google received the page HTML |
2 | Key pages are indexed | Page indexing report | Every important page is indexed |
3 | Sitemap URLs work | Page indexing report, sitemap filter | No sitemap URL returns 404 |
4 | Index and snippet controls are intended | URL Inspection | No unplanned noindex or nosnippet, and no conflicting tags |
5 | Content and metadata are in the HTML | URL Inspection | Main text, title and canonical are in the HTML Google received |
6 | Moved URLs use permanent redirects | Browser Network tab | 301 or 308 |
7 | Core Web Vitals pass in field data | PageSpeed Insights | LCP 2.5 s or less, INP 200 ms or less, CLS 0.1 or less |
8 | Lab performance score (diagnostic, field data decides) | PageSpeed Insights | 90 or above |
9 | Structured data is valid and matches the page | Rich Results Test | No errors, and values match the visible text |
10 | Key pages get internal links | Your navigation and content | Each key page is linked from a page Google knows |
11 | Language signals are correct | Page source | hreflang links each language version, and lang matches the page (for browsers and screen readers) |
12 | HTTPS is enforced | Browser | http moves permanently to https |
The sections below explain each group. The examples come from a site audit of madebyaris.com on 7 October 2026.
### Crawl and index (checks 1 to 4)
A page must be indexed to appear in Search. To appear as a link in AI Overviews or AI Mode, it must also be eligible for a snippet. Crawling must be allowed in robots.txt, and also by your CDN or hosting. URL Inspection shows the HTML that Googlebot received.
Use the Page indexing report for checks 2 and 3. Search Console Help for this report says not every URL needs to be indexed, for example duplicates. Your key pages must be indexed. Filter the report by sitemap to see only submitted URLs.
Findings on madebyaris.com:
- 6 URLs in the sitemap returned 404. They were old blog posts. An earlier audit found them on 25 September 2026.
- The 404 page had two robots meta tags: noindex and “index, follow”.
- The robots.txt on the WordPress subdomain pointed to a sitemap that returned 404. The subdomain is noindex, so the impact is small.
To fix the first finding, remove dead URLs from the sitemap. Or redirect each one to a replacement page. For the second, keep one robots instruction per page.
### Rendering on Next.js and headless WordPress (check 5)
Google asks that important content is available in text form. On a JavaScript site, check the HTML that Google received, not only what your browser shows. In URL Inspection, look for the main text, the title and the canonical.
On Next.js App Router, my setup is to set the title and description on the page that owns the URL. I use metadata for a static page and generateMetadata for a dynamic page, with defaults in the root layout. My post on SEO metadata in Next.js App Router explains why.
On headless WordPress, the WordPress backend should not compete with the public site. On madebyaris.com, the backend subdomain sends noindex, nofollow, and Next.js serves the public pages.
### Core Web Vitals (checks 7 and 8)
The Core Web Vitals are LCP, INP and CLS. PageSpeed Insights reports field data from real Chrome users over the previous 28 days. It shows the 75th percentile. Good means LCP up to 2.5 s, INP up to 200 ms and CLS up to 0.1.
The lab score comes from Lighthouse. A score of 90 or above is good. Lab and field data can disagree, because the lab test uses one device and one network.
Fix field failures first, because they show what real users get. A new or small page can have no field data.
### Structured data (check 9)
Google asks that structured data matches the visible text on the page. Test each template in the Rich Results Test. madebyaris.com uses Service, FAQPage, BreadcrumbList and BlogPosting.
Set your expectations. Google’s Search documentation updates page says FAQ rich results stopped appearing on 7 May 2026. How-to rich results are also gone. A FAQ section is still useful, but for readers, not for a rich result.
### Internal links and redirects (checks 6 and 10)
Google recommends that content is easy to find through internal links. A page needs a link from a known page, or a sitemap entry, before Google can find it.
Check redirects in the browser Network tab. Google’s redirects documentation lists 301 and 308 as permanent, and 302, 303 and 307 as temporary. On madebyaris.com, www.madebyaris.com redirected with a 307, which is temporary. The http version used a 308, which is correct.
### Language and HTTPS (checks 11 and 12)
Every page on madebyaris.com used lang=”en”, including the Indonesian pages. The site had no hreflang. Google reads the language from the visible content, not the lang attribute, so hreflang is the fix that matters. For a two-language site, this is a fix to plan in the templates.
For HTTPS, type your domain with http and confirm it moves permanently to https.
### AI search readiness
AI Overviews and AI Mode have no extra technical requirements. A page still needs snippet eligibility to appear as a link (check 4). An llms.txt file is not on Google’s list. For more, read Google AI Mode and your website.
### How to prioritise fixes
- Anything that blocks crawling or indexing of a key page.
- Broken sitemap URLs and temporary redirects on moved URLs.
- Content or metadata missing from the HTML Google received.
- Core Web Vitals that fail in field data.
- Structured data errors and language signals (hreflang).
### Questions about technical SEO audits
#### What does a technical SEO audit include?
A technical SEO audit checks crawling, indexing, rendering, redirects, speed, structured data, internal links, language signals and HTTPS. It does not review your writing or your backlinks, because those belong to on-page and off-page SEO. The 12 checks above cover the core, and each one names a free tool and a pass result.
#### Can I do a technical SEO audit myself?
Yes, you can run the checks yourself, because Search Console, PageSpeed Insights and the Rich Results Test are free. None of the three tools needs code, so you only enter a URL and read the result. The fixes are a different job, because redirects, rendering and structured data can live in templates or server settings.
#### Does a technical SEO audit improve rankings?
An audit is a diagnosis that finds what stops Google from crawling, indexing or understanding your pages. Fixing those problems makes your pages eligible to appear, but it does not guarantee a position. I do not promise rankings, and I tell you which fixes matter most for the pages you care about.
### What to do next
If the problem is in Next.js rendering or WordPress templates, ask a developer to read the code. Then run the 12 checks again and compare.
If you want a developer to run these checks on your site, see my technical SEO services.
For an Indonesian version of the basics, read technical SEO adalah. Send your URL through the contact page. I reply within 24 hours.
---
## Google AI Mode and your website: what changes for SEO
URL: https://madebyaris.com/blog/what-is-google-ai-mode
Published: 2026-10-13. Updated: 2026-10-19.
If Google now shows an AI Mode button to your customers, this post explains what Google says changes for your website and what you can check.
Google AI Mode is an AI search mode in Google Search. It answers with an AI response and links to supporting websites. Google says a page needs no special markup or file to appear there.
Last checked against Google’s own pages: 7 October 2026.
### What Google AI Mode is
AI Mode is Google’s AI search experience inside Google Search. You ask a question and get an AI response with links to the web. You can ask follow-up questions.
Google says AI Mode splits your question into subtopics and searches each one at the same time. Google calls this “query fan-out”.
You can open AI Mode in three ways, per Google’s Help page:
- Go to google.com/ai.
- Search on google.com and tap AI Mode.
- Tap AI Mode on the Google app home screen.
That matters for the worry about clicks. Google does not say AI Mode replaces links. Google’s Search Central doc says AI Mode shows “links to supporting websites”.
### AI Mode, AI Overviews and Gemini
These three names refer to different things. AI Overviews is a summary on the normal results page. AI Mode is a separate mode for questions that need more exploration, reasoning or comparison. Gemini is the Google model family that powers both.
Name | Where you see it | What it does |
AI Overviews | On the normal results page, only for some queries | A short AI summary with links. Google says it often does not show. |
AI Mode | A separate mode, tab or google.com/ai | An AI response with links, for questions that need more exploration. You can ask follow-ups. |
Gemini | Not a page in Search. It is the model | Google uses Gemini models to power AI Overviews and AI Mode. |
Google says the two features “may use different models and techniques”. So the links they show can differ for the same question.
### What Google says site owners must do
Google says you need nothing extra. The Search Central doc “AI features and your website” was last updated on 10 December 2025. It says a page must be indexed and eligible to show with a snippet. It also says: “There are no additional technical requirements.”
The rest is normal SEO. Google lists crawl access, internal links, page experience, text content and structured data that matches the page. The doc also says specific optimization is not required for AI Overviews and AI Mode.
### 5 checks to stay eligible as a linked source
Each check maps to one line in Google’s doc. Run them on the page you want people to find.
- Indexing. Open the URL Inspection tool in Search Console. Confirm that Google has indexed the page.
- Snippet controls. Check the page for noindex, nosnippet and max-snippet. Google uses these controls to limit what Search shows, in AI features too.
- Crawl access. Check robots.txt for Googlebot. Ask your host or CDN if it blocks Googlebot.
- Visible text. Put the important content in text on the page. Link to the page from other pages on your site.
- Structured data. Test the page in the Rich Results Test. The structured data must match the visible text.
Page experience is part of Google’s list too. I check it with PageSpeed Insights.
These checks keep a page eligible. They do not guarantee a link in AI Mode. Google picks the links, and I cannot control that choice.
### How to measure AI Mode traffic
Google counts AI Mode clicks inside your normal Search traffic. In Search Console, they are in the Performance report under the “Web” search type. Google’s doc names no separate AI Mode report.
RankMySEO can also show Search Console data. RankMySEO is my own SEO tool, so read its numbers with that in mind.
### Example: madebyaris.com
madebyaris.com already has a sitemap, schema and llms.txt. Its robots.txt allows the main AI crawlers. llms.txt is not on Google’s list, so I treat it as documentation for tools.
The 5 checks above do not test sitemap entries. A site audit found 6 sitemap URLs on my own site that return 404. It found them on 25 September 2026 and again on 7 October 2026. It also found a 404 page with two robots meta tags, noindex and “index, follow”.
### AI Mode timeline
These dates come from Google’s blog, by publish date.
Date | What Google announced |
20 May 2025 | AI Mode rolls out in the U.S., with no Labs sign-up. |
9 Sep 2025 | AI Mode launches in Indonesia, in Bahasa Indonesia. |
7 Oct 2025 | AI Mode reaches over 200 countries and territories, with more than 35 new languages. |
27 Jan 2026 | You can ask a follow-up from an AI Overview and continue in AI Mode. |
19 May 2026 | Google says AI Mode passed one billion monthly users. Gemini 3.5 Flash becomes the default model in AI Mode. |
### Questions about Google AI Mode
#### Is Google AI Mode free?
Google’s Help page lists three ways to open AI Mode and names no fee for normal use in Search. It also says Gemini 3 Pro in AI Mode has daily usage limits that may change with demand. After you reach the limit, you can wait for it to refresh or upgrade to a Google AI plan.
#### Can you trust Google AI Mode answers?
Check the links before you act, because Google’s Help page says AI Mode does not always get it right. Google says AI Mode can misinterpret web content or miss context, like any automated system in Search. Google also advises you to check important information in more than one place and open the linked sources.
#### Can I keep my site out of AI Mode?
Yes, you can use the normal Search controls, because Google applies them to AI features in Search as well. Use robots.txt for Googlebot to control crawling, and nosnippet, data-nosnippet, max-snippet or noindex to limit what Search shows. Google-Extended covers some other Google systems, and the doc does not list it as a Search control.
#### What can AI Mode do?
AI Mode answers questions that you ask with text, voice, images or files, including PDFs and Drive files. It takes follow-up questions and, if your history is on, lets you pick up later. You can also paste the URL of a webpage into the Ask anything bar and ask about that page.
### Next steps
My SEO for AI vs GEO post covers the wider split between ranking and citation. Read SEO for AI and LLMs vs GEO for that. This post covers Google AI Mode only. For how I track ranks after a launch, read how I check ranks after I ship.
If the 5 checks fail on your site, that is technical work. I take it through technical SEO services.
For a Next.js site, the page is Next.js SEO services. For a WordPress site, the page is WordPress speed optimization service. For any other site, use the contact page.
Send me the URL that should be found. I will check what Google receives and reply within 24 hours with what I would fix first. I do not promise rankings or AI Mode links. If the code is fine and the gap is content, I will tell you.
---
## Next.js 16.4: apa yang baru dan kapan website kamu perlu upgrade
URL: https://madebyaris.com/blog/next-js-16-4-apa-yang-baru
Published: 2026-10-07. Updated: 2026-10-19.
Next.js 16.4 sudah dirilis, tetapi perlu tidaknya website kamu ikut upgrade sekarang bergantung pada versi Next.js yang sedang terpasang. Yang lebih mendesak sebenarnya adalah patch keamanan untuk versi di bawah 16.3.8.
Saya sudah mencoba upgrade ini di website saya, madebyaris.com. Upgrade-nya saya jalankan lewat agent AI, yaitu program yang bisa mengubah kode dan menjalankan perintah secara otomatis.
Semuanya saya kerjakan di branch terpisah, jadi belum ada yang berubah di website yang sedang live. Prosesnya lancar: kode aplikasi tidak perlu diubah, semua cek otomatis lolos, dan 14 halaman yang dites bisa dibuka di server uji.
Halaman utama setelah upgrade, di server uji lokal.
Halaman services, dari server uji yang sama.
### Jawaban singkat
- Next.js 16.4.0 dirilis 6 Oktober 2026 waktu AS (7 Oktober 2026 WIB).
- Perubahan terbesarnya: tim Next.js mulai menyarankan Cache Components, yaitu fitur yang menyimpan bagian halaman supaya tidak perlu dibuat ulang setiap kali halaman dibuka.
- Blog resmi Next.js tidak mencantumkan breaking change (perubahan yang membuat kode lama harus diubah).
- Upgrade ke 16.4 bisa ditunda, tetapi website yang masih di bawah 16.3.8 perlu segera naik ke 16.3.8 supaya dapat patch keamanan yang dirilis 30 September 2026.
### Apa yang berubah di Next.js 16.4
Apa yang berubah | Versi | Dampaknya untuk website | Sumber |
Tim Next.js menyarankan Cache Components untuk semua website. Project baru yang dibuat lewat create-next-app langsung memakainya. | 16.4. Di 16.3, Cache Components masih opsional dan harus dinyalakan lewat pengaturan. | Website yang sudah ada tidak otomatis memakainya, walaupun Cache Components akan menjadi default di Next.js 17. | blog, docs cacheComponents, docs create-next-app |
File yang dikirim ke browser lebih kecil | 16.4 | Tidak perlu pengaturan tambahan. | blog |
Versi React | Next.js 16.4 memakai React 19.3 | React 19 disarankan. React 18 masih didukung, tetapi sudah deprecated dan tidak didukung lagi mulai Next.js 17. | docs React Version Support, blog index |
Breaking change | 16.4 | Blog tidak mencantumkannya, tetapi versi baru tetap perlu dites sebelum dipakai. | blog |
Node.js minimal 20.9 | Sama untuk 16.4 dan 16.3 terakhir | Kalau server sudah menjalankan 16.3, versi Node.js (program yang menjalankan Next.js di server) tidak perlu diganti. | npm |
Patch terbaru | 16.3.8 dan 15.5.27, dari security release 30 September 2026. 16.4.0 belum punya rilis patch. | Website Next.js 16 di bawah 16.3.8 perlu naik ke 16.3.8. Website Next.js 15 perlu naik ke 15.5.27. | blog index, npm |
### Kapan kamu perlu upgrade
Daftar berikut dimulai dari kondisi yang paling mendesak, yaitu website yang belum mendapat perbaikan keamanan 30 September 2026. Cocokkan dengan versi Next.js yang terpasang di website kamu:
- Di bawah 16.3.8: naikkan ke 16.3.8 sekarang, karena versi itu memuat perbaikan keamanan tersebut.
- Di Next.js 15: naikkan ke 15.5.27 supaya dapat perbaikan yang sama.
- Di 16.3.8: jadwalkan upgrade ke 16.4 saat tim siap, walaupun support policy Next.js tetap menyarankan agar website sebisa mungkin memakai versi terbaru.
- Dengan pengaturan cache khusus atau server sendiri: tes dulu di staging sebelum upgrade.
Untuk pindah dari Next.js 15 atau versi yang lebih lama ke 16.4, website perlu melalui migrasi, jadi ikuti dulu panduan upgrade ke versi 16.
### Kalau kamu developer: cara upgrade Next.js ke 16.4
Langkah berikut kita kerjakan berurutan. Empat di antaranya, yaitu langkah 1, 2, 5, dan 6, sudah dites pada 7 Oktober 2026 di project uji yang dibuat dari nol dengan create-next-app 16.3 dan berisi satu halaman serta satu route handler.
- Cek versi Next.js dan Node.js yang terpasang, karena Next.js 16.4.0 butuh Node.js 20.9 ke atas.
```
npx next --version
node -v
```
- Buat branch baru dari main.
```
git checkout -b upgrade-next-16-4
```
- Jalankan perintah upgrade dari dokumentasi Next.js sesuai package manager yang dipakai, dan pilih salah satu saja.
```
pnpm next upgrade
npx next upgrade
yarn next upgrade
bunx next upgrade
```
Versi sebelum 16.1.0 belum punya perintah upgrade, jadi untuk versi itu dokumentasi memakai codemod:
```
npx @next/codemod@canary upgrade latest
```
Upgrade manual juga bisa:
```
npm i next@latest react@latest react-dom@latest eslint-config-next@latest
```
Di project uji, yang dites hanya npx next upgrade dan perintah manual npm i, sedangkan perintah pnpm, yarn, bun, codemod, dan --agent diambil dari dokumentasi dan tidak dijalankan di sana.
- Opsional: biarkan coding agent mengerjakan dan mengecek upgrade-nya, dengan catatan fitur ini masih experimental.
```
npx next@canary upgrade --agent=latest
```
- Lihat diff sebelum commit, karena langkah ini sering terlewat. Waktu dites, npx next upgrade mengunci versi @types/react dan menambah blok overrides di package.json.
- Jalankan npm run build dan npm run lint, lalu baca semua warning.
Keduanya lolos di 16.4.0 pada project uji. Pages Router dengan React 18 memang memunculkan warning saat build (PR #97689), jadi kalau ingin pindah router, baca migrasi Pages Router ke App Router.
- Jangan langsung merge, karena hasil di satu website belum tentu sama di website lain. Deploy ke preview dulu, lalu cek halaman utama, form, dan route data. Untuk toko online, klik juga tombol pesan lewat WhatsApp sebelum merge.
Perubahan teknis lain, termasuk fitur experimental, ada di blog resmi Next.js 16.4.
#### Hasil upgrade di website saya
Upgrade madebyaris.com saya jalankan pada 7 Oktober 2026 lewat agent AI yang sama, tetapi dengan codemod Next.js, bukan npx next upgrade. Versi yang dipakai adalah Node.js 22.14.0 dan pnpm 9.15.3.
Semua perubahannya tersimpan di branch chore/nextjs-16-4, dalam draft pull request yang belum di-merge, jadi upgrade ini belum live.
```
pnpm dlx @next/codemod@latest upgrade 16.4.0 --yes --verbose
```
Output terminal saat upgrade, sudah dibersihkan dari data sensitif sebelum dipublikasikan.
Di branch itu, paket next, eslint-config-next, dan @next/bundle-analyzer naik dari 16.3.6 ke 16.4.0, sedangkan React tetap 19.3.0. Codemod hanya mengubah package.json dan pnpm-lock.yaml, dan proses install-nya selesai dalam 5,8 detik.
Build, lint, dan dua cek lain selesai dengan exit 0, sementara route utama di server uji merespons dengan status 200. Kecepatan sebelum dan sesudah upgrade tidak diukur.
Cache Components tetap nonaktif di branch ini, karena menurut catatan di next.config.js fitur ini bentrok dengan export const revalidate di tiap route. Log juga mencatat beberapa warning, tetapi semuanya sudah muncul di 16.3.6 sebelum upgrade atau tidak terkait upgrade.
### Pertanyaan soal Next.js 16.4
#### Apakah website kamu harus langsung upgrade ke Next.js 16.4?
Tidak harus, kalau website kamu sudah di Next.js 16.3.8, karena versi itu sudah memuat perbaikan keamanan 30 September 2026. Kalau masih di bawah 16.3.8, naikkan ke 16.3.8 sekarang, lalu jadwalkan upgrade ke 16.4 setelah dites dulu di staging. Versi yang sudah ditambal tercantum di pengumuman security release pada indeks blog Next.js.
#### Apakah upgrade ke Next.js 16.4 bisa membuat website rusak?
Belum ada tanda seperti itu, karena blog resmi Next.js 16.4 tidak mencantumkan breaking change sama sekali. Meski begitu, file hasil build tetap berubah, jadi versi baru sebaiknya tidak langsung dipasang di website yang sedang live. Minta developer kamu mengetesnya dulu di staging, terutama halaman pesanan dan form yang paling sering dipakai pelanggan.
#### Apa itu Cache Components, dan apakah wajib?
Tidak wajib, karena upgrade ke 16.4 tidak otomatis menyalakannya, walaupun fitur ini akan menjadi default di Next.js 17. Misalkan ada toko batik online di Solo yang daftar produknya jarang berubah, tetapi stoknya bisa berubah setiap jam. Dengan Cache Components, daftar produk itu bisa disimpan dan langsung tampil, sedangkan angka stok tetap diambil ulang setiap kali halaman dibuka.
#### Apakah hosting atau server website perlu diganti?
Tidak perlu, kalau VPS atau hosting yang kamu sewa sekarang sudah menjalankan Next.js 16.3 dengan baik. Syaratnya juga tidak berubah, karena Next.js 16.4 butuh Node.js 20.9 atau lebih baru, sama seperti rilis 16.3 terakhir, sehingga versi Node.js di server yang sama tidak perlu diganti. Kalau ragu, versi Node.js di server bisa dicek dengan perintah node -v.
### Sumber
Terakhir dicek: 7 Oktober 2026.
- Blog resmi Next.js 16.4: fitur baru, Cache Components, ukuran file, dan tanggal rilis.
- Indeks blog Next.js: security release 30 September 2026 dan React 19.3.
- Dokumentasi cacheComponents dan dokumentasi create-next-app.
- React Version Support: dukungan React 18 dan 19.
- Dokumentasi Upgrading Next.js dan panduan upgrade ke versi 16.
- Support policy Next.js.
- Paket next di npm dan daftar versinya: syarat Node.js dan patch terbaru.
- PR #97689: warning React 18 di Pages Router.
- Log upgrade madebyaris.com di branch chore/nextjs-16-4, dari draft pull request yang belum di-merge.
### Butuh bantuan upgrade Next.js?
Jadi, yang perlu didahulukan adalah patch keamanan (16.3.8, atau 15.5.27 untuk Next.js 15), sedangkan upgrade ke 16.4 bisa dijadwalkan setelah dites di staging. Langkah pertamanya cukup menjalankan npx next --version, atau meminta developer kamu mengecek versi Next.js yang terpasang.
Mau website Next.js kamu diperbarui? Hubungi madebyaris. Saya balas dalam 24 jam.
---
## When a Website Actually Needs Machine Learning
URL: https://madebyaris.com/blog/when-a-website-needs-machine-learning
Published: 2026-09-22. Updated: 2026-09-24.
A website needs machine learning when the job is pattern recognition or prediction that rules and search cannot cover well at scale. Rules and search are often enough for clear policies, catalogs, and findability. Prefer a written decision before you hire anyone to “add AI.”
I get this from founders and product owners who were told to “add ML” and are unsure it is needed. This is a decide post, not an integrate how-to. If you already know you need a model in a Next.js product, jump to the sibling on how to integrate a machine learning model into a Next.js product. Here we stay on whether ML earns a seat at all.
### Short answer
Use machine learning when patterns beat hand-written rules at the scale you actually have. Prefer rules and search when the problem is enumerable, policy-driven, or mostly about finding known content.
ML is a tool with data, ops, and failure modes. Rules and filters are often the honest product.
### What people mean by “add ML to the website”
When someone says “add ML to the site,” they usually mean one of a few jobs. Naming the job stops fake-AI SOWs.
- Ranking. Order results, feeds, or leads by predicted usefulness, not only by a fixed sort.
- Recommendations. Suggest products, content, or next actions from behavior and similarity.
- Classification. Label tickets, reviews, uploads, or spam risk into buckets.
- Generation. Draft text, summaries, or structured fields from prompts and context.
Marketing buzz (“AI-powered”) is not a job. If the brief cannot name ranking, recommendations, classification, generation, or another concrete prediction task, you have a slide, not a model requirement yet.
### When rules are enough
I push teams toward rules when most of these are true.
- Business policy is clear and stable (eligibility, pricing tiers, access, compliance gates).
- The state space is small enough that a human can list the cases and expected outcomes.
- You need explainability for audits, support, or regulated flows. “The model said so” is not enough.
- Errors have a known fix path: change the rule, publish, done.
Rules are software you can read. If a spreadsheet or a config table already captures the decision, start there. You can always add a model later if the rule set becomes a mess of exceptions that no one can maintain.
### When search (and filters) are enough
Findability problems are often mislabeled as ML problems.
- Catalogs, docs, help centers, and blogs usually need better indexing, synonyms, facets, and filters before a recommender.
- Users asking “where is X” need retrieval, not a black-box score.
- Empty results and bad taxonomy hurt more than the absence of a model.
Improve search and filters first. Measure whether people find what they came for. If ranking still fails after clean metadata and solid query handling, then talk about learned ranking. Do not skip the boring layer because “AI” sounds better in a deck.
### When ML earns its keep on a site
ML starts to earn its keep when the product has a real pattern problem.
- Noisy inputs. Free text, images, messy user behavior, or signals that do not map cleanly to if/else.
- Personalization at scale. Too many users and items for hand-tuned segments to stay honest.
- Signals rules cannot enumerate. Combinations and weak cues that only show up in volume, not in a policy meeting.
Even then, write a measurement plan before you hire. Define what “better” means in product terms: fewer false labels, better click quality on known sets, faster triage, fewer support loops. Without a measurement plan, you are buying a model and hoping, and hope is not acceptance criteria.
I will not invent ROI percentages or case-study clients here. Your decision should rest on the job, the data you can own, and whether you can tell when the model is wrong.
### When not to
- No labeled data and no owner. If nobody will label, maintain, or review outputs, the model will rot.
- “AI” as a slide. If the only requirement is to say the product is AI-powered, stop. That is branding, not Build scope.
- Problems that are really UX or content debt. Confusing navigation, thin copy, broken taxonomy, and slow pages do not need a model, they need product work.
- Assume everyone needs ML. Many sites ship well with rules, search, and clear product logic.
Killing a fake-ML SOW early is a win, and it saves budget for the constraint you actually have.
### If you decide yes
If the decision is yes, the next job is integration shape, not another definition essay. For a Next.js product, start with a thin input/output contract, a versioned inference path or worker, auth, logging, and a fallback. I walk that path in how to integrate a machine learning model into a Next.js product (without boiling the ocean).
This post stops at the decision. Do not treat it as a remake of SEO-with-AI tips or a generic “optimize the website with AI” checklist. Those are different intents.
If you have written the decision, named the job, and still need help scoping or shipping the Build side, that is work I take through AI development. Bring the use case, what rules or search already cover, and how you will measure “good enough.” We can decide whether a model belongs before anyone writes a vague SOW.
---
## Integrating Machine Learning into a Next.js Product
URL: https://madebyaris.com/blog/integrate-machine-learning-into-nextjs-product
Published: 2026-09-22. Updated: 2026-09-24.
Integrating a machine learning model into a Next.js product usually means calling a versioned inference API (or a worker) from the app, not training inside the page request. Start with a thin input/output contract, auth, logging, and a fallback when the model fails, then expand only after that slice ships.
I write this for founders and product engineers who already have (or will have) a model and a Next.js app. You are past the slide deck, and you need a shape that ships without rebuilding the whole stack for a demo.
### Short answer
Pick one integration shape. Ship a thin slice. Do not rebuild the stack for a model that has not proven itself in production traffic.
Most solid first versions look like this: the Next.js app accepts a request, validates a small payload, calls a model service (or enqueues a job), stores or returns the result, and degrades gracefully when the model is slow or down. Training stays offline, secrets stay on the server, and the UI does not talk to the model directly.
If you are still unsure whether ML belongs in the product at all, decide that first. I covered the product decision in when a website actually needs machine learning. This post assumes you already said yes and need to wire it in.
### What “integrate a model with a website” usually means
People say “integrate ML with the website” and mean three different jobs. Mixing them is how scopes explode.
- Inference API. The app (or a backend it owns) sends features or text to a model endpoint and gets a prediction, score, label, or embedding back. This is the default for product features.
- In-process or edge inference. The model runs close to the request path (same process, sidecar, or edge runtime). Useful for hard latency or privacy constraints. Rare as a first slice because packaging, memory, and cold starts get expensive fast.
- Batch or offline jobs. A worker scores users, products, or content on a schedule or queue. The Next.js product reads the results from a database or cache. Good when you do not need an answer inside the same HTTP request.
Training, data labeling, and model research are upstream work. Keep them out of the Next.js request path unless you enjoy outages.
### Next.js-shaped options
In a Next.js app you usually choose among a few practical shapes. I am describing patterns, not ranking vendors.
Route Handlers or server actions calling a model service. The browser hits your app. A server-only path validates input, authenticates the user, calls your inference service over HTTPS, and returns a trimmed result. Pros: familiar Next.js surface, secrets stay server-side, easy to add rate limits and logging. Cons: the request waits on the model, so you need timeouts and a clear failure mode.
Queue plus worker. The app writes a job (score this order, classify this upload, generate this draft). A worker pulls the job, runs inference, writes the result. The UI polls, subscribes, or refreshes when ready. Pros: protects request latency, retries are natural, heavy models do not sit in the web tier. Cons: more moving parts, and you must design for “pending” states in the product.
Third-party inference API. Your server calls a hosted model endpoint instead of running your own. Pros: faster to a thin first slice when you do not want to operate GPUs on day one. Cons: you still own auth, budgets, data handling, fallbacks, and the product contract. Swapping providers later is easier if your app talks to your own thin adapter, not directly from every component.
Edge runtimes and bundling a model into the Next.js deploy are possible. I treat them as special cases: only when latency, data residency, or cost math force it, and only after a simpler API or worker shape has proven the feature.
### Without boiling the ocean
The difference between a shippable integration and a six-month science project is fencing.
- Freeze inputs and outputs. Write the JSON (or protobuf) contract first: required fields, types, max sizes, and what “unknown” looks like. Change the model behind the contract. Do not let every experiment rewrite the UI.
- Version the model. Ship with a model id or version string. Log it with every prediction. When quality dips, you need to know which version answered.
- Auth and rate limits. Inference endpoints are expensive and leaky if left open. Authenticate callers, cap abuse, and prefer server-to-server calls over exposing the model URL to the browser.
- Logging. Capture request id, user or tenant id (if allowed), latency, model version, and outcome class (success, timeout, validation error, model error).
- Fallback when the model is down. Return a safe default, a cached prior result, a rules path, or a clear “unavailable” state. Silent empty responses train users to distrust the feature.
Ship that fence for one use case, one page, one flow, then expand. “AI everywhere” is how SOWs grow and products stall.
### What not to do
- Do not train inside the web request. Training belongs in jobs, notebooks, or pipelines. A page load is the wrong place for a training loop.
- Do not put secrets in the client. API keys, model tokens, and private endpoints never ship in browser bundles or public env vars.
- Do not buy an “AI everywhere” SOW. If the proposal cannot name the first input, first output, and first fallback, it is not scoped.
- Do not treat an editor or coding agent as architecture. Tools help you write code, they do not replace a data contract, ops ownership, or acceptance criteria.
### Hire / scope checklist
Before you hire someone to wire a model into Next.js, write these down. No day-rate tables. Just scope that survives a kickoff.
- Data contract. Exact inputs, outputs, validation rules, PII rules, and retention.
- Latency budget. How long the user (or the job) can wait. Sync vs async is a product choice, not a preference.
- Who owns ops. Who deploys the model, who watches error rates, who rolls back a bad version, who pays the inference bill.
- Eval and acceptance. What “good enough to ship” means: sample set, failure modes you will tolerate, and how you will re-check after changes.
- Fallback and kill switch. How the product behaves when the model fails, and how you turn the feature off without a full redeploy drama.
If a vendor cannot walk those items without inventing vanity metrics, keep looking. Integration is product engineering with a model behind a fence.
### Related
Still deciding whether ML is justified at all? Read when a website actually needs machine learning (and when rules + search are enough). That is the decide post, this one is the integrate post.
If you want a broader buy-scope view of wiring AI into an existing product (not the Next.js-shaped how-to above), see the sibling page on AI integration services.
If you already have a model (or a clear candidate) and a Next.js product, and you want help shipping a thin, guarded first slice, that is Build work I take on through AI development. Bring the data contract, the latency budget, and who owns ops. We can scope from there without boiling the ocean.
---
## Using Cursor Agent for Shipping Production Code
URL: https://madebyaris.com/blog/cursor-agent-for-shipping
Published: 2026-09-21. Updated: 2026-09-24.
Cursor Agent helps when you want the tool to take multi-step actions on a real repo. For client shipping, keep the scope small, keep secrets out, and review every diff before merge. Agent speed without guardrails is just a faster way to break main.
If you already live in Cursor and you keep hearing “just use Agent,” this is the shipping frame I use on client work, not a docs clone or a feature tour: what I let Agent touch, what I do not, and how the PR still has to pass a human.
### What Cursor Agent is for (shipping frame)
Agent is for an agentic loop on a real repository. You give an outcome, it plans steps, edits files, runs commands, and comes back with a diff. That is different from a single chat answer or a one-shot Composer paste.
I reach for Agent when the job is multi-step and boring in a good way: “add tests for this module,” “rename this prop across these files,” “wire this form to the existing API shape.” I do not reach for it when I cannot describe done in one or two sentences.
On a deadline, Agent is a junior pair with infinite typing speed, and you still own merge.
### Agent vs Composer (one screen)
Quick split so this post does not redo the full chat-vs-composer writeup.
- Composer (or focused edit flows): tight, local changes when you already know the files. Fast when scope is one screen.
- Agent: multi-step work across files, with room to run checks and iterate. Useful when the path is longer than a single edit.
- Chat: explain, explore, decide. Not the merge path by itself.
If you want the deeper comparison, use the sibling post chat vs Composer in Cursor. Here we stay on Agent habits for shipping.
### What I let Agent touch
On client repos I give Agent room inside a fence.
- Scoped files. Named folders or paths in the brief. Not “improve the app.”
- Tests. Add or extend tests for behavior we already agreed on.
- Boring refactors. Renames, extract helpers, align types to an existing pattern.
- Glue that matches the repo. Wire a component to an API shape that already exists. Copy patterns from neighboring files.
- Check runs. Lint, typecheck, unit tests that the project already has. Agent should run them before it claims done.
The brief I paste usually has: outcome in product language, in-scope paths, out-of-scope paths, and what “done” looks like (test green, UI state, or API response). Without that, Agent invents a tour.
### What I don’t
Hard no on client work, even when Agent sounds confident.
- Secrets. Env files, keys, tokens, production credentials. Agent does not need them in context. If the task needs a secret, I handle that outside the loop.
- Blind prod deploys. No “just push to main and deploy” as an Agent step. Staging first. Human clicks the risky button.
- Huge unreviewed diffs. If the diff is a novel, I stop, split the job, or discard and restart smaller.
- Auth, billing, migrations without a human plan. Those get a written approach before Agent types.
- Drive-by architecture. New folders, second design systems, “temporary” any-casts that somehow ship.
Those land when the fence is missing.
### Guardrails so the PR passes
This is the habit that keeps Agent useful past the demo.
- Brief first. Outcome, scope, exclusions, done criteria. Paste that before the agent runs.
- Small scope. One vertical slice. Prefer two small Agent runs over one mega run.
- Run checks. Types, lint, tests. If the project has them, Agent should use them. If checks fail, fix before review theater.
- Human review every diff. Open the files. Skim for pattern drift. Reject rubber-stamp summaries.
- Own the PR description. You explain risk and test notes. Agent can draft. You sign.
Theo’s line in my head: own Agent. Do not outsource judgment. Speed is only useful if main stays shippable.
### Related Cursor posts
This post is only Agent constraints on client repos. Sibling posts cover adjacent jobs:
- Cursor MCP setup for shipping – tools and MCP when you need them in the loop.
- Cursor vibe coding workflow – fast loop with taste and review, not improvisation.
I am not remaking those here. Read them when that is the job you have today.
If Agent is already in your editor and you want a second set of eyes on how you fence client work, that is mentoring territory. I do that through Vibe Code Friend. Bring a real repo habit you want to tighten. We stay on shipping practice and review habits, not a product rebuild engagement.
---
## Migrasi WordPress ke Next.js untuk Bisnis
URL: https://madebyaris.com/blog/migrasi-wordpress-ke-nextjs-bisnis
Published: 2026-09-21. Updated: 2026-10-24.
Migrasi WordPress ke Next.js masuk akal bila bisnis butuh performa, alur mirip aplikasi, atau kontrol SEO dan teknis yang tema klasik sulit penuhi. Banyak situs masih cukup di WordPress. Bayar migrasi hanya setelah risiko konten, redirect, dan maintenance tertulis – bukan karena tren saja.
Saya sering dapat chat dari pemilik bisnis atau digital lead di Indonesia: situs WP sudah jalan, tapi mulai sempit. Lambat. Susah ditambah fitur. Tim marketing frustrasi. Vendor bilang “saatnya pindah ke Next.” Yang perlu dijawab: migrasi worth it untuk bisnis Anda sekarang, atau lebih aman tetap di WP dulu?
### Jawaban singkat
Migrasi masuk akal bila salah satu atau lebih kondisi ini jelas:
- Pengalaman pengguna butuh alur mirip aplikasi, bukan sekadar halaman company profile.
- Performa dan SEO teknis sudah digarap di WP, tapi tetap mentok karena arsitektur tema atau builder.
- Integrasi (CRM, auth, dashboard, sistem internal) lebih masuk akal sebagai kode aplikasi daripada tumpukan plugin.
- Ada owner proyek, anggaran, dan orang yang akan maintain setelah go-live.
Tetap di WordPress bila situs utamanya konten, tim editorial sudah nyaman di wp-admin, plugin masih cukup, dan belum ada kapasitas untuk migrasi konten plus maintenance stack baru. Pindah hanya karena “semua orang pakai Next” biasanya berakhir mahal dan setengah jadi.
### Migrasi artinya apa
Migrasi WordPress ke Next.js berarti rebuild front-end (dan sering stack), bukan ganti tema atau pasang plugin headless lalu selesai. Yang biasanya terjadi:
- Pindah front-end. Situs publik dibangun ulang di Next.js. Konten bisa tetap di WP (headless) atau pindah ke CMS lain.
- Pindah stack. Hosting, deploy, preview, dan cara update konten ikut berubah. Tim harus belajar alur baru.
- Bukan sekadar redesign. Desain baru tanpa rencana URL, redirect, dan model konten tetap migrasi setengah matang.
Kalau vendor menjual “migrasi” tapi deliverable-nya cuma landing Next tanpa peta konten dan redirect, itu proyek website baru, bukan migrasi yang aman untuk bisnis yang sudah punya traffic.
### Sinyal situs WP sudah sempit
Sinyal yang sering saya lihat sebelum owner mulai cari migrasi:
- Performa. Sudah cache, sudah bersihkan plugin, tetap lambat di perangkat nyata yang dipakai pelanggan.
- UX app-like. Butuh alur bertingkat, area login, filter kompleks, atau komponen yang dipakai berulang di banyak halaman. Tema klasik mulai melawan tiap sprint.
- SEO teknis. Struktur URL, rendering, atau Core Web Vitals sulit dikontrol tanpa melawan page builder.
- Integrasi. Setiap fitur baru = plugin baru. Stack plugin saling bentrok. Developer khawatir update.
- Tim produk vs tim konten. Marketing butuh publish cepat, product butuh front-end yang bisa diuji dan di-deploy seperti aplikasi.
Satu sinyal saja belum otomatis berarti harus migrasi. Kumpulkan sinyal, tulis dampak bisnisnya, baru buka diskusi scope.
### Risiko yang sering dilupakan
Ini bagian yang jarang muncul di pitch vendor murah.
- Konten. Siapa memindahkan ratusan halaman, meta, gambar, dan custom field? Siapa yang tandatangani “konten sudah dicek”?
- Redirect. URL lama harus punya peta 301. Tanpa itu, ranking dan backlink bisa goyah.
- Tim editorial. Kalau editor kehilangan wp-admin tanpa pelatihan dan preview yang nyaman, konten berhenti update setelah launch.
- Hosting dan deploy. Next butuh alur deploy yang jelas. Siapa pegang akses, staging, dan rollback?
- Maintenance. Dependency, keamanan, dan bug setelah go-live. Migrasi tanpa retainer atau owner internal sering mati pelan-pelan.
Saya minta risiko itu tertulis sebelum DP. Bisnislah yang menanggung dampaknya, bukan slide deck vendor.
### Checklist sebelum bayar vendor
Sebelum transfer, minta jawaban tertulis untuk poin ini.
- Scope tertulis. Halaman dan fitur mana yang masuk, mana yang fase dua. Headless WP + Next, atau full custom tanpa WP?
- Staging. Ada lingkungan uji sebelum production. Soft launch dan rencana rollback jelas.
- SEO. Peta URL, redirect, sitemap, tracking. Siapa yang verifikasi setelah live.
- Siapa isi konten. Vendor, tim internal, atau campuran. Jadwal freeze konten sebelum cutover.
- Handoff. Akses repo, hosting, dokumentasi singkat, dan kontak untuk bug minggu pertama.
- Contoh kerja. Link live atau studi kasus yang bisa dicek, bukan hanya mockup homepage.
Saya tidak menulis angka harga rata-rata di sini. Angka palsu menyesatkan. Bandingkan quote berdasarkan scope dan risiko yang sama, bukan paket termurah di marketplace.
### Beda dari “jasa website murah”
Migrasi adalah proyek dengan utang SEO, konten, dan operasional, beda dari paket landing lima halaman dengan revisi unlimited. Kalau Anda masih di tahap cari partner untuk situs bisnis dari nol atau company profile yang lebih rapi, konteksnya beda. Saya sudah tulis sudut jasa website Jakarta di jasa pembuatan website Jakarta Next.js. Artikel ini fokus ke keputusan migrasi dari WP yang sudah hidup.
Vendor yang menjual migrasi seperti paket landing biasanya mengabaikan redirect, model konten, dan maintenance. Harga murah di muka, biaya tersembunyi setelah traffic turun atau editor mogok.
Kalau sinyal di atas sudah terkumpul dan Anda butuh partner Build untuk migrasi atau front-end Next.js, saya terima kerja lewat Next.js development Indonesia. Bawa daftar halaman penting, masalah yang paling sakit hari ini, dan siapa yang akan maintain setelah live. Dari situ kita bisa tulis scope, bukan opini stack.
Kalau checklist bilang tetap di WordPress dulu, itu keputusan yang sah. Perbaiki yang ada, amankan performa dan editorial, baru buka migrasi saat produk benar-benar butuh front-end aplikasi.
---
## WordPress vs Next.js: Kapan Harus Pindah?
URL: https://madebyaris.com/blog/wordpress-vs-nextjs-when-worth-it
Published: 2026-09-21. Updated: 2026-10-25.
WordPress vs Next.js is a buy decision, not a fandom contest. WordPress is often enough for content-led sites with a stable editorial team. Next.js, or headless WordPress with a Next front end, fits when you need product-shaped UX, stronger performance control, or app-like flows that classic themes fight. Decide from constraints and rewrite risk, then hire against a written checklist.
I get this question from founders and marketing owners before they pay for a rewrite quote. They need a hire-side decision tree: when stay on WordPress is the smart move, and when Next.js (or a headless middle path) is worth the project risk.
### Short answer
Stay on WordPress when the site is mostly content, your editors already know the workflow, plugins cover the jobs, and performance is good enough for the business goal. A rewrite without budget, content ownership, or a maintenance plan is usually worse than a tuned theme.
Move toward Next.js when the product surface matters more than the CMS admin. Think dashboards, authenticated flows, custom checkout steps, marketing pages that share a design system with the app, or SEO and performance work that theme layers keep blocking. Headless WordPress plus Next is the middle path when you want to keep editorial in WP and ship the front end as a real app.
Decide from the constraint that forces a leave, and from the rewrite risk that leave creates.
### What “WordPress vs Next.js” usually means
People say “WordPress vs Next.js” when they mix three different setups.
- Classic WordPress. Theme or page builder, plugins, PHP hosting. Editors publish in wp-admin. This is still the default for many business sites.
- Custom Next.js. React app with routes, APIs, auth, and a design system. Content may live in a headless CMS, Markdown, or a custom admin. You own the front-end architecture.
- Headless WordPress + Next. WP stays as the content API. Next renders the public site. You keep editorial habits and gain a product-shaped front end.
Comparing “WordPress” to “Next.js” without naming which of those three you mean leads to bad quotes. Classic WP and a full Next rebuild are different projects. Headless is a third scope. Ask vendors to say which one they are pricing.
### Stay on WordPress if…
I push teams to stay on WordPress when most of these are true.
- An editorial team already publishes weekly and knows Gutenberg or their builder.
- Plugin coverage is honest: forms, SEO basics, membership, or e-commerce already fit without stacked hacks.
- Performance is “good enough” for lead gen or content goals after caching and cleanup, not after wishful thinking.
- There is no budget or owner for a rewrite, content model redesign, and ongoing Next maintenance.
- The site is mostly pages and posts, not an app with complex client state.
A stable WP site with clear ownership beats a half-finished Next migration. If you need help hardening or extending WordPress without a full rewrite, that is a different service path than a Next rebuild. See WordPress services or headless options when editors must stay in WP.
### Move toward Next.js if…
Next.js becomes worth the hire when constraints keep showing up in the theme layer.
- Product UX. You need flows that feel like a product: multi-step forms, logged-in areas, interactive pricing, shared components with the app.
- Performance and SEO control. You want predictable rendering, routing, and Core Web Vitals work without fighting a page builder stack.
- App-like surface. Marketing and product share one design system. Classic themes fight that every release.
- Integrations. Custom APIs, CRM hooks, or auth that already live better as application code than as plugin glue.
- Headless editorial. Marketing still needs WP (or another CMS) for content, but the public site must ship as a front-end app.
Those constraints mean the front-end job has outgrown classic themes. Hire for the constraint you actually have, not for a stack trend.
### Headless as a middle path
Headless WordPress with Next is the compromise I recommend most often when editors refuse to leave wp-admin and the public site needs a product front end. WP remains the content source. Next owns routing, layout, and performance.
That path is still a real project: content modeling, API contracts, preview, redirects, and who maintains both sides. It is not “install a plugin and flip a switch.” For the how-to side of that setup, I already wrote a sibling guide: headless WordPress with Next.js. This post stays on the buy decision, not the install steps.
### Checklist before you pay for a rewrite
Before you sign a rewrite quote, write these down. If a vendor cannot answer them, the quote is still a conversation starter, not a price.
- Scope. Classic WP tune-up, headless, or full custom Next? Which pages and flows are in, which are out.
- Content model. Who owns content types, migrations, and editorial training after launch.
- SEO redirects. URL map, 301 plan, sitemap, and who verifies that rankings do not fall off a cliff.
- Design system. Are we matching an existing product UI, or inventing marketing pages in isolation.
- Integrations. Forms, CRM, analytics, auth, payments. Named owners for each.
- Who maintains. Hosting, deploys, dependency updates, content preview. Name the person or team.
- Staging and launch. Soft launch, rollback, and content freeze window.
I will not invent rate tables here. Cost follows scope, risk, and who owns maintenance. Fake averages teach buyers to optimize the wrong variable.
If your constraints point at Next.js or a headless front end, I take Build work through Next.js development. Bring a short list of pages, the flows that hurt today, and who will own content after launch. We can turn that into a written scope instead of a stack opinion.
If the checklist says stay on WordPress for now, that is a valid outcome. Tune the site you have, fix performance and editorial friction, and revisit Next when the product surface actually needs it.
---
## Apakah Cursor AI gratis, dan kapan perlu beli Pro
URL: https://madebyaris.com/blog/apakah-cursor-ai-gratis
Published: 2026-09-17. Updated: 2026-09-17.
Cursor AI punya opsi hemat dan opsi berbayar. Untuk belajar, jalur hemat sering cukup. Untuk kerjaan client yang padat, banyak orang naik plan saat limit mulai memutus kerja. Cek harga resmi di situs Cursor sebelum memutuskan.
Saya pakai Cursor hampir tiap hari untuk kerja client dan mentoring. Pertanyaan yang paling sering masuk dari freelancer Indonesia kurang lebih sama: "Apakah Cursor AI gratis? Kalau belum Pro, masih bisa produktif nggak?"
Jawaban singkatnya: ada jalur untuk mulai tanpa langsung bayar plan atas. Mengandalkan jalur hemat selamanya untuk semua pola kerja biasanya tidak realistis kalau Anda sudah full-time nge-ship fitur dengan agent.
Angka plan berubah, jadi saya tidak rewrite daftar harga di sini. Yang saya tulis: kapan jalur hemat biasanya cukup, kapan Pro (atau plan di atasnya) mulai terasa, dan praktik freelance biar uang tool tidak sia-sia. Untuk angka terkini, buka halaman pricing resmi Cursor di cursor.com/pricing.
### Jawaban singkat
- Ya, Cursor punya opsi untuk mencoba dan belajar dengan biaya rendah atau tanpa langganan berbayar di awal, tergantung kebijakan produk saat Anda daftar.
- Tidak, mengandalkan jalur hemat untuk workload client yang padat sering terasa sempit. Limit, model, atau fitur agent biasanya jadi hambatan lebih dulu daripada "editornya jelek".
- Naik plan saat kerja Anda terhenti oleh kuota atau saat waktu tunggu/kompromi model sudah lebih mahal daripada biaya langganan.
- Jangan hafalkan angka dari artikel lama. Cek cursor.com/pricing. Plan name dan benefit bisa berubah.
Kalau Anda hanya ingin jawaban operasional: mulai di jalur hemat, ukur satu minggu kerja nyata, baru putuskan upgrade. Jangan upgrade karena FOMO komunitas.
### Kapan jalur hemat biasanya cukup
Jalur hemat (free / Hobby / tier awal, sebutan bisa berubah) biasanya cukup di kondisi berikut.
Anda masih belajar repo dan alur editor Tab completion, chat untuk menjelaskan kode, refactor kecil, dan eksplorasi codebase. Belum ada deadline client yang ketat.
Volume prompt rendah Beberapa sesi sehari, bukan agent yang jalan panjang berulang kali.
Side project atau exercise Yang penting selesai belajar, bukan kecepatan ship fitur produksi tiap hari.
Anda sudah punya kebiasaan review diff Anda tidak membutuh agent "menulis setengah aplikasi" dalam satu malam. Anda butuh bantuan fokus.
Budget tool sedang ketat Wajar. Banyak freelancer Indonesia mulai hemat dulu. Yang penting disiplin: jangan habiskan waktu mengakali limit sampai lebih mahal dari langganan.
Tanda jalur hemat masih oke: Anda jarang kehabisan kuota di tengah tugas, dan kualitas jawaban masih cukup untuk unblok.
Tanda sudah tidak oke: Anda menunda kerja karena limit, atau menurunkan kualitas model hanya supaya "masih gratis", lalu menghabiskan dua jam memperbaiki hasilnya.
### Kapan Pro terasa
Pro (atau nama plan berbayar setara di masa depan) biasanya terasa saat pola kerja berubah.
Kerjaan client harian Anda buka Cursor sebagai editor utama. Agent dan chat jadi bagian dari loop implementasi, bukan sesekali.
Limit mulai memutus flow Anda berhenti di tengah PR karena kuota. Context switching ke tool lain lebih mahal daripada bayar plan.
Anda pakai agent untuk implementasi, di luar sekadar tanya Tanya penjelasan beda beban dengan minta agent apply perubahan di banyak file.
Review dan kualitas lebih penting Anda butuh ruang untuk iterasi prompt, bukan sekali jalan lalu habis.
Tim kecil mulai seragam tool Kalau dua tiga orang sudah bergantung pada workflow yang sama, inkonsistensi plan bisa bikin proses berantakan. Tetap cek kebijakan resmi untuk seats/tim.
Saya biasanya bilang ke mentee: upgrade saat rasa frustrasi limit sudah berulang, bukan saat lihat thread Twitter. Kalau dalam seminggu Anda dua tiga kali "kehabisan di jam penting", itu sinyal lebih jujur daripada spekulasi harga.
Ingat: plan berbayar bukan jaminan kode bagus. Tanpa aturan repo, tanpa review diff, Anda hanya bayar untuk menghasilkan junk lebih cepat. Pro membeli kapasitas, disiplin yang menentukan hasil.
### Beda dari artikel harga lama
Saya pernah menulis soal skema harga Cursor di post Indonesia: Tentang skema harga Cursor IDE. Angka dan nama benefit di artikel lama bisa sudah tidak sama dengan yang berlaku hari ini.
Anggap artikel harga sebagai foto waktu. Produk AI editor bergerak cepat: nama plan, included usage, agent limits, dan model pool bisa diganti tanpa Anda sadari.
Cara pakai konten lama dengan aman:
- Baca logikanya (plan fee vs usage, kapan overage terasa).
- Jangan copy angka ke proposal client atau keputusan budget tanpa cek ulang.
- Konfirmasi di cursor.com/pricing dan di dashboard akun Anda.
Kalau ada perbedaan antara artikel komunitas dan situs resmi, menang situs resmi.
### Praktik freelance
Ini yang saya sarankan ke freelancer yang tanya "apakah Cursor AI gratis" dengan nada khawatir budget.
Pisahkan belajar vs billable Sesi belajar boleh hemat. Saat jam billable client, hitung opportunity cost. Satu jam stuck karena limit bisa lebih mahal daripada sebulan plan, tergantung rate Anda.
Ukur seminggu, bukan sehari Hari pertama sering "masih cukup". Pola limit baru kelihatan setelah beberapa project paralel.
Jangan kejar model termahal sepanjang waktu Banyak tugas cukup dengan model yang lebih hemat di dalam ekosistem Cursor. Simpan model berat untuk arsitektur, bug sulit, atau diff besar. (Nama model berubah; lihat opsi di editor Anda.)
Pasang pagar di repo Rules, struktur folder, perintah test, dan kebiasaan review. Tool berbayar tanpa pagar tetap bisa merusak codebase.
Catat jenis tugas yang paling boros Kalau borosnya dari "minta generate ulang UI 15 kali tanpa brief", masalahnya proses, bukan plan.
Jangan campur biaya tool ke client secara gelap Kalau Anda charge client, putuskan apakah tool cost masuk overhead Anda atau di-itemize. Yang penting transparan ke diri sendiri dulu.
Upgrade bertahap Naik satu tingkat saat ada bukti pemakaian, bukan loncat ke plan paling atas karena takut ketinggalan.
Punya exit habit Kalau Cursor down atau limit, Anda tetap bisa lanjut di editor biasa untuk tugas sempit. Ketergantungan total tanpa fallback berisiko.
Intinya: pertanyaan "gratis atau tidak" kurang lengkap. Pertanyaan yang lebih berguna: "Pada pola kerja saya bulan ini, jalur mana yang tidak memutus pengiriman ke client?"
Kalau Anda sudah pakai Cursor tapi masih sering berantakan di repo client, atau ragu kapan upgrade karena belum punya workflow yang rapi, saya bisa bantu lewat mentoring Level-up.
Lihat Vibe Code Friend. Kita kerjakan di codebase Anda: rules, kebiasaan review, dan cara pakai agent tanpa membakar kuota untuk junk. Ini mentoring Level-up di repo Anda (bukan jalur Hire untuk dibuatkan project dari luar).
---
## Jasa Website Company Profile: Template vs Custom
URL: https://madebyaris.com/blog/jasa-website-company-profile-nextjs-vs-template
Published: 2026-09-17. Updated: 2026-10-24.
Jasa website company profile cocok dengan template bila halaman sederhana dan jarang diubah. Custom atau stack modern masuk akal bila Anda butuh performa, banyak landing, atau alur konten yang lebih fleksibel. Putuskan dari kebutuhan, bukan dari katalog tema.
Saya sering dikirimi screenshot tema WordPress atau Figma template dengan caption: "Aris, ini bagus nggak?" Pertanyaannya kurang tepat. Tema bisa bagus di demo, tapi tidak otomatis cocok untuk cara bisnis Anda update konten, generate lead, atau scale halaman layanan.
Artikel ini membedakan kapan template cukup dan kapan masuk akal bayar custom, dari sisi operasional lebih dari selera desain.
### Company profile vs toko online
Sebelum pilih template atau custom, pastikan dulu jenis situsnya.
Company profile biasanya fokus ke kepercayaan: siapa Anda, layanan apa, bukti kerja, kontak, dan kadang blog atau insight. Konversi utamanya sering form, WhatsApp, atau booking meeting. Katalog produk bisa ada, tapi bukan keranjang belanja penuh.
Toko online beda. Ada katalog, stok, checkout, pembayaran, ongkir, dan alur order. Stack dan plugin-nya ikut berubah. Banyak orang bilang "mau company profile" padahal yang dimaksud marketplace mini. Itu dua project berbeda.
Kalau Anda masih campur keduanya di brief, tahan dulu. Tulis satu kalimat tujuan situs:
- "Prospek B2B percaya lalu isi form / chat."
- "Pengunjung beli produk online dengan pembayaran."
- "Hiring dan employer branding."
- "Support campaign bulanan dengan banyak landing."
Dari situ baru bicara template vs custom. Jasa pembuatan website company profile yang sehat mulai dari tujuan, bukan dari jumlah halaman di paket.
### Template cukup jika
Template (WordPress theme, block theme, atau starter yang sudah matang) sering cukup bila kondisi ini terpenuhi.
Halaman terbatas dan stabil About, services, portfolio, blog, contact. Jarang berubah struktur. Yang berubah biasanya teks dan foto.
Tim non-teknis yang update konten Editor butuh panel yang familiar. WordPress klasik atau block editor sering lebih ramah daripada repo plus pull request.
Anggaran dan waktu lebih ketat Anda butuh online dalam hitungan minggu dengan risiko teknis rendah, bukan design system dari nol.
Tidak ada alur aplikasi berat Tidak ada dashboard user, auth kompleks, multi-tenant, atau UI yang sangat custom.
SEO masih di tahap dasar sampai menengah Struktur URL sederhana, konten layanan jelas, blog untuk topik pendukung. Belum butuh arsitektur rendering yang rumit.
Vendor atau internal bisa maintain tema dengan aman Update inti, backup, dan keamanan masih terjaga. Tema resmi, bukan bajakan.
Contoh konkret: konsultan lokal dengan 6 halaman, update portofolio dua bulan sekali, lead via form. Template yang rapi, cepat, dan di-setup dengan benar sering sudah menyelesaikan pekerjaan.
Tanda template "cukup" muncul karena kompleksitas bisnisnya memang rendah. Kalau Anda memaksa custom di sini, Anda bayar fleksibilitas yang jarang dipakai.
Satu catatan: template cukup tetap butuh kerja. Copywriting, foto, struktur heading, tracking, dan kecepatan masih harus dikerjakan. Template bukan pengganti brief.
### Custom / stack modern jika
Bayar custom atau stack modern masuk akal bila kebutuhan sudah keluar dari "tema plus plugin".
Banyak landing dengan komponen berulang Tim marketing butuh halaman campaign tiap bulan. Desain harus konsisten, tapi konten beda-beda. Component-driven lebih hemat jangka panjang.
Performa jadi syarat, bukan bonus Mobile speed, LCP, dan pengalaman di jaringan Indonesia benar-benar memengaruhi lead quality. Anda siap investasi di arsitektur, image pipeline, dan caching yang lebih terkendali.
Alur konten lebih dari editor biasa Preview staging, role editorial, headless CMS, atau integrasi ke tools internal.
UI atau interaksi di luar kemampuan tema Kalkulator, configurator, dashboard ringan, personalisasi, atau animasi yang terikat data.
Multi-language atau multi-site yang non-trivial Struktur URL dan konten yang rapi, plugin translate asal biasanya tidak cukup.
Migrasi dari situs lama yang berantakan Anda butuh redesign plus cleanup teknis, redirect map, dan QA. Custom plan sering lebih jujur daripada "pasang tema baru di atas sampah lama".
Produk dan marketing sudah menyatu Situs adalah bagian dari funnel yang diukur tiap minggu.
Custom bukan selalu berarti "bikin semua dari nol tanpa CMS". Bisa berarti WordPress yang dikustom berat, headless, atau Next.js dengan CMS. Intinya: Anda bayar kontrol dan fleksibilitas karena ada use case yang memerlukannya.
Kalau belum punya use case itu, custom sering jadi biaya spekulatif.
### WordPress, headless, Next.js (singkat)
Ini peta singkat, bukan perang stack.
WordPress (tradisional) Kuat untuk company profile dan konten editorial. Plugin ekosistem besar. Cocok bila editor non-teknis jadi pengguna utama. Risiko muncul saat tema/plugin numpuk tanpa disiplin.
WordPress + kustomisasi serius Masih WordPress, tapi blok custom, CPT, dan pola konten yang dirancang. Jalan tengah yang sering saya pakai untuk bisnis yang butuh fleksibilitas tanpa lompat penuh ke app stack.
Headless CMS terpisah dari frontend. Fleksibel untuk banyak channel, tapi operasional lebih kompleks. Cocok jika ada alasan jelas (multi-site, multi-channel, atau tim engineering yang siap).
Next.js / frontend modern Masuk akal untuk performa, routing, dan UI product-like. Butuh skill maintain yang beda. Jangan pilih hanya karena "lagi hits".
Untuk banyak jasa pembuatan website company profile di Indonesia, WordPress yang bersih masih pilihan pragmatik. Next.js atau custom lebih sering menang saat situs mendekati produk atau mesin campaign yang agresif.
Yang saya tegaskan ke client: stack mengikuti brief. Brief mengikuti bisnis. Bukan sebaliknya.
### Cara membaca penawaran
Penawaran bagus bisa dibaca tanpa tebak-tebakan. Pakai pertanyaan ini.
Apa yang termasuk halaman vs fitur? "5 halaman" tanpa daftar isi menyesatkan. Minta daftar: Home, About, Services (berapa item), Case studies, Blog index + template single, Contact.
Siapa yang menulis konten? Banyak harga murah mengasumsikan Anda menyetor semua teks dan foto siap pakai. Itu sah, asal tertulis.
Template apa, lisensi apa? Tema berbayar resmi atau custom theme. Bajakan adalah red flag.
Revisi dan change request Berapa putaran desain. Apa yang dihitung change setelah lock.
SEO yang mana? Setup teknis dasar beda dengan content strategy. Jangan campur dalam satu kalimat "termasuk SEO" tanpa pecahan.
Akses dan ownership Hosting, domain, CMS admin, analytics. Harus di akun bisnis Anda.
Maintain Update, backup, keamanan, dan tarif request kecil setelah live.
Timeline dengan checkpoint Wireframe atau IA, desain, development, QA, training.
Kalau penawaran hanya menampilkan harga paket dan screenshot tema, Anda belum punya cukup informasi untuk bayar DP. Minta addendum scope. Satu halaman bullet sering sudah menyelamatkan project.
Cara bandingkan dua vendor: samakan scope dulu, baru bandingkan harga dan proses. Membandingkan "paket A 5 halaman" dengan "custom 12 landing + CMS" tidak berguna.
Kalau Anda sedang memutuskan jasa pembuatan website company profile dan cenderung ke jalur WordPress yang rapi (template kuat atau kustomisasi yang masuk akal), saya bisa bantu lewat jalur Build.
Lihat jasa pembuatan website WordPress. Kirim brief: tujuan situs, daftar halaman, siapa yang edit konten, dan apakah ada rencana banyak landing ke depan. Dari situ kita tentukan template cukup atau perlu custom, sebelum Anda bayar untuk fleksibilitas yang tidak terpakai.
---
## Jasa pembuatan website Jakarta: checklist sebelum DP
URL: https://madebyaris.com/blog/jasa-pembuatan-website-jakarta-nextjs
Published: 2026-09-17. Updated: 2026-10-24.
Jasa pembuatan website Jakarta berarti memilih partner untuk situs bisnis. Template murah cocok untuk kebutuhan sederhana. Custom atau Next.js masuk akal bila produk, performa, atau SEO teknis lebih penting daripada harga terendah. Bayar DP setelah scope dan contoh kerja jelas.
Saya sering dapat pesan singkat dari owner di Jakarta atau sekitarnya: "Aris, mau bikin website, berapa?" Pertanyaan itu wajar. Masalahnya, jawaban "berapa" tanpa checklist biasanya berakhir di salah pilih vendor, karena ekspektasi dan deliverable tidak pernah disepakati di atas kertas.
Artikel ini adalah checklist sebelum Anda transfer DP. Fokusnya: beda vendor murah vs tim yang bisa maintain dan bantu SEO teknis, plus kapan stack modern seperti Next.js masuk akal.
### Siapa yang biasanya mencari ini
Orang yang mencari jasa pembuatan website Jakarta biasanya punya salah satu kondisi ini.
Pertama, bisnis sudah jalan. Ada produk, ada lead WhatsApp, tapi situs masih template lama atau belum ada sama sekali. Mereka butuh situs yang bisa dipercaya prospek, sampai ada domain saja tidak cukup.
Kedua, situs lama sudah bermasalah. Lambat, susah diedit, plugin numpuk, atau ranking turun setelah update tema. Mereka mencari partner yang bisa benerin arah teknis setelah paket "bikin dari nol murah" sudah tidak menjawab masalah.
Ketiga, tim marketing mulai butuh landing baru tiap bulan. Company profile statis sudah tidak cukup. Mereka butuh struktur halaman yang rapi, performa yang bisa diukur, dan proses update yang tidak selalu menunggu developer.
Keempat, founder yang sudah coba freelancers murah sekali dua kali. Hasilnya jalan di awal, lalu stuck saat butuh fitur, keamanan, atau SEO teknis. Mereka datang dengan trauma kecil: takut bayar lagi tanpa kepastian.
Kalau Anda di salah satu kelompok itu, pertanyaan yang tepat adalah siapa yang bisa menjelaskan scope, maintain, dan risiko teknis sebelum DP.
### Yang sering ditawarkan murah
Pasar jasa website di Jakarta (dan online secara umum) penuh penawaran murah. Tidak semua buruk. Beberapa memang cukup untuk kebutuhan sederhana. Yang perlu Anda waspadai adalah pola penawaran yang terdengar lengkap tapi kosong di detail.
Yang sering muncul:
- Paket "company profile 5 halaman" tanpa daftar halaman dan tanpa wireframe.
- "SEO included" tanpa menjelaskan on-page, struktur URL, sitemap, Core Web Vitals, atau siapa yang nulis konten.
- "Hosting gratis setahun" tanpa siapa yang pegang akses, backup, dan update.
- "Revisi unlimited" tanpa batas waktu, tanpa definisi revisi, tanpa lock scope.
- Portfolio yang hanya screenshot homepage, tanpa link live atau case yang bisa dicek.
Murah jadi masalah saat murahnya datang dari shortcut. Tema bajakan. Plugin gratis yang tidak dirawat. Copy paste dari template lain. Tidak ada staging. Tidak ada dokumentasi. Tidak ada rencana handoff.
Saya tidak anti template. Saya anti janji besar tanpa artefak. Kalau vendor bilang "bisa maintain dan SEO", minta contoh kerja, cara mereka update, dan siapa yang tanggung jawab setelah go-live.
Bedanya kurang lebih begini.
Vendor murah biasanya menjual halaman. Tim yang serius menjual sistem kerja: scope, repo atau akses, proses revisi, performa dasar, dan jalur maintain.
Vendor murah jarang bicara technical SEO di luar meta title. Tim yang serius bisa menjelaskan struktur heading, internal link, kecepatan, dan cara konten di-deploy.
Vendor murah hilang setelah DP atau setelah launching. Tim yang serius punya cara komunikasi, backlog kecil, dan batasan yang jelas soal apa yang masuk retainer vs request baru.
Anda tidak selalu butuh yang mahal. Anda butuh yang jujur soal batasan.
### Kapan Next.js / custom masuk akal
Tidak setiap bisnis di Jakarta butuh Next.js. Banyak yang cukup dengan WordPress atau template yang dirawat dengan baik. Custom atau Next.js masuk akal di kondisi tertentu.
Pertimbangkan custom atau Next.js bila:
- Produk digital atau SaaS yang butuh UI cepat dan interaksi yang tidak nyaman di tema generik.
- Banyak landing page dengan komponen berulang, A/B, atau personalisasi ringan.
- Performa dan Lighthouse atau Core Web Vitals jadi bagian dari target bisnis, bukan hiasan proposal.
- Tim Anda punya (atau mau punya) workflow content atau design system yang lebih terkontrol.
- SEO teknis butuh kontrol routing, metadata, rendering, dan struktur URL yang lebih halus.
- Integrasi ke API, dashboard, auth, atau alur aplikasi yang sudah keluar dari "halaman statis plus form".
Next.js adalah stack, bukan jalan pintas. Kalau yang Anda butuhkan hanya profil perusahaan 5 halaman dan update sekali setahun, custom bisa overkill. Biaya maintain dan skill yang dibutuhkan juga beda.
Kalau Anda ragu, mulai dari kebutuhan, bukan dari tren. Tulis dulu: halaman apa saja, siapa yang update, seberapa sering, dan metrik sukses apa (lead form, demo booking, organic traffic ke halaman layanan), dari situ baru pilih stack.
Saya biasanya arahkan ke Next.js saat situs adalah bagian dari produk atau mesin akuisisi yang harus cepat dan mudah di-iterasi. Untuk company profile sederhana, jalur lain sering lebih masuk akal. Yang penting: keputusan itu ditulis sebelum DP, bukan setelah desain selesai.
### Checklist sebelum DP
Ini bagian yang saya harap Anda copy ke chat dengan vendor.
1. Scope tertulis Daftar halaman, fitur, integrasi (form, CRM, analytics, chat), bahasa, dan apa yang tidak termasuk. Kalau ada "SEO", pecah: riset keyword, on-page, teknis, atau hanya setup dasar.
2. Contoh kerja yang bisa dibuka Link live, bukan hanya PDF. Tanya peran mereka di project itu: full build, partial, atau redesign.
3. Stack dan alasan WordPress, headless, Next.js, atau hybrid. Alasan harus nyambung ke kebutuhan Anda, bukan ke kebiasaan vendor saja.
4. Siapa yang punya akses Domain, hosting, repo, CMS, analytics. Idealnya akun di atas nama bisnis Anda, dengan akses vendor yang bisa dicabut.
5. Proses revisi Berapa putaran, apa beda revisi vs change request, dan bagaimana lock desain sebelum development.
6. Performa dasar Target kasar untuk mobile speed, image policy, dan apakah ada staging sebelum production.
7. SEO teknis minimum URL bersih, title/description, heading, sitemap, robots, redirect plan jika ada migrasi, dan tracking dasar.
8. Maintain setelah live Apakah ada retainer, response time, update dependency, backup, dan cara request fitur baru.
9. Timeline realistis Milestone: wireframe, desain, development, QA, training, go-live. Bukan hanya "2 minggu" tanpa checkpoint.
10. Pembayaran yang nyambung ke deliverable DP setelah scope clear. Pelunasan bertahap di milestone, bukan 100% di muka tanpa artefak.
Kalau 5 dari 10 poin di atas dijawab kabur, tahan dulu DP. Clarifikasi lebih murah daripada rebuild.
Satu tip praktis: minta vendor menjelaskan trade-off. "Kalau kita pilih A, Anda dapat X, tapi Y jadi lebih mahal atau lebih lambat." Vendor yang hanya bilang "bisa semua" sering belum memikirkan maintain.
### Harga tanpa angka palsu
Saya tidak akan taruh tabel IDR fiktif di sini. Harga jasa pembuatan website di Jakarta sangat bergantung pada scope, stack, jumlah halaman, integrasi, kualitas desain, dan apakah ada migrasi atau content ops.
Yang bisa saya bilang tanpa mengarang angka:
- Template sederhana dengan sedikit kustom biasanya lebih rendah biayanya daripada custom app-like site.
- Custom atau Next.js biasanya lebih tinggi di awal, tapi bisa lebih rapi untuk iterasi dan performa jika scope-nya memang butuh itu.
- "Termurah" sering memotong maintain, QA, atau dokumentasi. Anda bayar selisihnya nanti.
- Bandingkan apple to apple: scope, ownership akses, dan support pasca live, bukan hanya angka di chat.
Kalau ada yang kasih harga sangat rendah untuk fitur yang terdengar enterprise, tanya detail. Biasanya ada yang dihilangkan: content, SEO, staging, atau support.
Cara baca penawaran yang sehat: total biaya = build + risiko + maintain. Kalau penawaran hanya menampilkan build, Anda belum melihat seluruh gambar.
Kalau Anda sedang memilih jasa pembuatan website Jakarta dan butuh partner yang jelas soal scope Next.js atau custom, saya bisa bantu lewat jalur Build.
Mulai dari halaman jasa pembuatan website Next.js. Kirim brief singkat: bisnis apa, halaman apa, siapa yang update, dan deadline. Dari situ kita bisa lihat apakah Next.js masuk akal, atau stack lain lebih pas, sebelum ada DP.
---
## What It Costs to Hire a Next.js Developer
URL: https://madebyaris.com/blog/cost-to-hire-nextjs-developer
Published: 2026-09-17. Updated: 2026-10-19.
Founders and engineering managers often ask about the “average cost to hire a Next.js developer” as if there is a single standard rate. In reality, average hourly rate tables from freelancing marketplaces tell you almost nothing about what your project will actually cost or whether it will ship successfully.
When you hire a Next.js developer, you are not buying raw typing speed. You are buying architectural judgment, risk reduction, performance optimization, and clean delivery. A low hourly rate often becomes the most expensive option when a junior engineer wraps the entire application in 'use client', destroys your search engine rankings, and inflates your server bills.
Here is an honest, transparent breakdown of how Next.js development costs are structured, what factors actually drive the price, and how to evaluate proposals to ensure you get high-performing, production-ready code.
### The Three Common Engagement Models
How you structure the contract determines both budget predictability and alignment of incentives:
#### 1. Fixed-Price Milestones or Sprints (Recommended)
For defined builds, migrations, or feature implementations, fixed-price milestones provide the greatest budget certainty. The developer writes a clear scope with explicit deliverables and exclusions. You pay for completed, tested outcomes rather than logged hours. This aligns incentives toward shipping efficiently.
#### 2. Hourly Billing
Common on freelancing platforms, ranging anywhere from $25/hr for offshore juniors to $150+/hr for senior specialized architects. Hourly billing works well for open-ended research, troubleshooting, or occasional maintenance. However, for core product development, hourly billing shifts all risk of delays onto the client.
#### 3. Dedicated Monthly Retainer
Suited for growing startups needing continuous feature delivery and ongoing maintenance without the overhead of full-time hiring. You secure dedicated senior capacity with consistent weekly communication and fast turnaround.
### What Actually Drives Next.js Development Costs
A simple marketing site and an interactive SaaS dashboard might both be built with Next.js, but their cost profiles differ dramatically. Here are the five real cost drivers:
- Architecture and rendering strategy: A site using pure static generation is straightforward. An enterprise application utilizing Partial Prerendering (PPR), complex cache tags, server-side data fetching, and streaming requires specialized App Router expertise.
- Data and API integration: Connecting to an existing GraphQL endpoint, headless CMS (like WordPress or Sanity), or relational database with authentication and role-based permissions adds necessary architectural layers.
- Migration complexity: Migrating an established legacy application (such as a WordPress monolithic site or an older Next.js Pages Router app) requires preserving URL structures, redirects, SEO metadata, and user accounts without downtime.
- Performance and Core Web Vitals requirements: Achieving 95+ Lighthouse scores and optimal Largest Contentful Paint (LCP) requires meticulous image optimization, font preloading, critical CSS management, and bundle analysis.
- Specification clarity: A project with detailed wireframes, user stories, and clear acceptance criteria takes substantially less time (and cost) than an ambiguous brief that requires extensive trial-and-error discovery.
### Red Flags to Watch for When Hiring
Next.js evolved significantly with version 15 and 16. Many general React developers claim Next.js expertise without understanding modern App Router fundamentals. Watch out for these warning signs:
- Treating Next.js like a Create-React-App single page app: If their proposed architecture puts 'use client' at the root layout, they are discarding all the server-rendering and SEO benefits you chose Next.js for.
- No discussion of caching or hosting costs: A poorly architected Next.js app can quickly run up thousands of dollars in unoptimized serverless function calls and ISR writes on Vercel. A senior developer designs cache lifetimes intentionally.
- Ignoring technical SEO: If metadata, Open Graph images, canonical tags, and structured JSON-LD data are treated as an afterthought, your organic traffic will suffer after launch.
### How I Scope and Quote Next.js Projects
In my independent consulting practice, I believe in complete transparency before any code is written:
- Initial scoping conversation: We discuss your product goals, technical constraints, timeline, and what success looks like.
- Written proposal: You receive a clear, written plan detailing exact milestones, deliverables, technical trade-offs, and a fixed cost.
- Weekly progress demos: You see working software deployed to staging every week, with direct communication and zero intermediate layers.
### Ready to Discuss Your Project?
If you have a new Next.js product build, a WordPress-to-Next.js migration, or an existing App Router app that needs performance and architectural improvements, let’s talk.
Visit my Next.js development services page, or reach out directly through the project contact form with a brief description of what you are building. I reply within 24 hours with an honest assessment of fit and scope.
---
## How to vibe-code in Cursor without making a mess
URL: https://madebyaris.com/blog/cursor-vibe-coding-workflow
Published: 2026-09-17. Updated: 2026-09-17.
“Vibe coding” gets used two ways. One is pure improvisation: open the agent, describe a feeling, accept whatever lands, merge when it kind of works. The other is a fast loop with taste and review. I use the second one on real Next.js work. The first one creates demos. The second one creates PRs you can defend.
Vibe coding in Cursor means using the AI loop to move fast on a real product. You still set scope, run checks, and review before merge. Skip that and you trade today's speed for tomorrow's rewrite.
This post stays off beginner “how to install Cursor” territory. You already have the editor. What you need is a habit that keeps momentum without letting the repo fill with almost-right code.
### What we mean by vibe coding here
In my practice, vibe coding means:
- Start from a clear outcome in product language.
- Let Cursor draft the boring middle.
- Stay in the loop for scope, verification, and taste.
- Commit small, readable slices.
The vibe is speed and flow. The coding is still engineering.
I still decide:
- Which folder is in play.
- What must not change (auth, billing, public APIs, migrations).
- What “done” looks like in the UI or API.
- Whether the diff matches patterns already in the repo.
Cursor decides how to fill in a lot of the syntax once those fences exist. That split is the whole game.
If you have been burned by AI diffs, you probably skipped the fences. The model will happily invent a new utils/ folder, a second button component, and a “temporary” any-cast that somehow ships. Vibe coding without guardrails just dumps chaos into the repo.
When I say vibe coding on client work, I mean the agent is in the room, not in charge of merge.
### Where it breaks
It usually breaks in the same places.
Scope creep in the prompt. You ask for a form fix and also “clean up the page” and also “while you’re here, improve loading.” The agent delivers a tour of the codebase. You spend the afternoon untangling it.
No run step. The diff looks fine in the panel. You never hit the route. Types fail later. A hook order bug shows up in staging. Review turns into digging through history you never meant to write.
Rubber-stamp review. The summary sounds confident. You approve the files you did not open. Two weeks later nobody knows why the data layer has a third fetch helper.
Missing product constraints. The agent optimizes for “compiles” instead of “matches the design system” or “keeps the existing error shape.” Fast code that fights your UI kit is not fast.
Vibes-only tickets. “Make it nicer” with no acceptance path. The agent invents a nicer that is not yours.
Context dumping. You paste half the repo into chat because you are unsure which files matter. The model gets noisy. You get a messy, overlapping change set.
The problem is usually not that AI is dumb. Speed without a loop feels productive until the rewrite starts.
I have cleaned up enough almost-shipped branches to be blunt: if you cannot explain the diff in two sentences, you are not vibe coding. You are generating.
### A simple loop (brief, generate, run, tighten, commit)
This is the loop I use when I want flow without a mess.
#### 1. Brief
Write the brief before Composer or Agent writes code. Keep it short:
- User-visible outcome.
- Files or folders allowed.
- Files or behaviors off-limits.
- How you will verify (route, test, or checklist).
Example shape, not a template to worship:
> Add inline validation to the checkout email field on /checkout. Reuse the existing field error component. Do not touch payment intent creation. Verify by submitting empty and invalid email on local.
That brief is the vibe. Vague vibes produce vague diffs.
#### 2. Generate
Ask for a small pass, not the whole epic.
- Pass A: the UI or API slice only.
- Pass B: tests or type fixes if needed.
- Pass C: cleanup only if something real is wrong.
I prefer vertical slices over “refactor everything related.” If the agent proposes a new abstraction, I ask whether an existing helper already does the job.
#### 3. Run
Run something that can fail:
- Typecheck / lint for the touched area.
- The unit or integration test that already covers the path, if you have one.
- Manual click-through on the route you named in the brief.
If you cannot run it yet, you are not done generating. You are drafting.
#### 4. Tighten
Now review like the author is a fast junior:
- Does this match the brief and only the brief?
- New dependencies you did not ask for?
- Duplicated logic that already exists in the repo?
- Naming that matches the domain you already use?
- Secrets, env vars, or logging that should not ship?
- Dead code or “temporary” comments that will stick around forever?
Tighten with a second, narrower prompt. Do not start a new vibe from scratch on top of a muddy tree.
#### 5. Commit
Commit a focused change with a message that a human can skim. If you need two commits because the agent mixed refactor and feature, split them before you push.
Then reset the vibe for the next slice. Fresh brief. Smaller blast radius. Same loop.
That is cursor vibe coding as a shipping habit: brief, generate, run, tighten, commit. Repeat until the ticket is honestly done.
### Guardrails
Guardrails are what keep the loop from rotting.
Project rules in git. Stack, folder map, preferred UI primitives, test command, “ask before schema or auth changes.” Rules are fences, not a novel. Update them when you learn a new “do not.”
Chat plans, Agent writes. Use chat to pressure-test the approach. Use Agent or Composer for the scoped diff. If you blur that, every conversation becomes a write session.
PR checklist for AI diffs. Blast radius, no surprise top-level folders, types match siblings, existing tests still meaningful, no “while we are here.”
One concern per PR when you can. Mixed refactors hide bugs and train the team to skim.
Revert early. If a pass went sideways, revert the files and regenerate with a sharper brief. Editing a confused AI diff by hand for an hour is how messes harden in place.
Keep secrets out of prompts and tools. Paste tokens into chat and you have created a new incident class. Use env files and existing secret handling.
Do not outsource taste. Design system tokens, empty states, error copy, and accessibility still need a human pass. The agent can draft. You still own the product feel.
These are not anti-AI rules. They are how AI stays useful after the first exciting week.
### Solo vs help
Solo, the loop is enough for many tickets: you brief yourself, you run the checks, you feel the quality bar in your gut.
Solo breaks down when:
- You are learning a new area of the codebase and cannot tell good duplicates from bad ones.
- The ticket touches auth, payments, or data migrations.
- You keep regenerating because the brief was never clear.
- Review is just you agreeing with yourself at midnight.
That is when help matters. Not “someone to write code for you,” but someone to install the habit on your real repo: sharper briefs, better rules, cleaner PR taste, and a loop you can repeat without me in the room.
Pairing on one painful ticket often teaches more than another generic Cursor tutorial. You see where your prompts leak scope. You see which rules would have blocked the bad diff. You leave with a checklist that fits your stack.
If you are already productive solo, keep going. Add help when the mess cost is higher than the pairing cost.
If you want that Level-up help on your own project, I offer it as Vibe Code Friend. We use your real repo, tighten the brief-generate-run-tighten-commit loop, and leave you with guardrails that survive busy weeks.
---
## Cursor MCP setup for shipping Next.js work
URL: https://madebyaris.com/blog/cursor-mcp-setup-for-shipping
Published: 2026-09-17. Updated: 2026-09-24.
Cursor’s marketplace and docs can make MCP look like a collectible. You open settings, see a long list of servers, and toggling everything on feels productive. I ship Next.js client work in Cursor every week, so the useful question is which few tools help me finish this PR without a noisy sidebar.
Cursor MCP lets the agent use external tools while you work in the editor. For shipping, enable a few servers that help a real repo, verify each one, and skip marketplace pile-ons. More servers does not mean more progress.
This page is the shipping version of MCP setup: keep vs collect, a small starting set by pattern (not a ranked vendor must-install list), how to wire one then expand, what matters on Next.js client work, and what I skip on purpose. If you want the broader production loop around Chat, Composer, and review, I already wrote that in How to use Cursor AI to ship faster without wrecking the codebase.
### What MCP does in Cursor
MCP (Model Context Protocol) is how Cursor connects the agent to external tools. Without it, the model mostly sees your open files, rules, and chat context. With it, the agent can call tools you have enabled: search, docs, project systems, browsers, and other helpers outside the editor.
That sounds powerful because it is, and it is also easy to over-enable.
When a server is on, the agent can propose tool calls. Those calls cost attention. They can pull in context you did not ask for. They can fail loudly mid-flow. They can tempt you into “while we are here, also check X” loops that never become a clean commit.
I treat MCP like dependencies in package.json. Every entry should earn its place on this repo, this week. If I cannot say what job it does during a normal shipping day, it stays off.
MCP does not replace project rules, tests, or PR review. It runs alongside them. If your rules and workflow are messy, more servers will not fix that. Clean the loop first, then add tools that support the loop.
### Keep vs collect
Docs list every server. Collectors enable them all. Shippers keep a short list.
I use a simple keep test before I leave a server enabled:
- Does this help a real PR this week? Not “might be cool someday.”
- Can I verify it in under ten minutes? Auth works, a sample call returns something useful, and I know what failure looks like.
- Does the agent know when to call it? If every prompt triggers noise, the server is too broad or my brief is too vague.
- Would I miss it tomorrow if I turned it off? If no, turn it off.
Collect mode looks like this: twenty servers enabled, three of them half-authenticated, and the agent spending half a turn deciding which tool to try. Keep mode looks like this: three to five servers, each with a clear job, each verified after a Cursor update.
I also separate “research day” tools from “finish the PR” tools. A docs browser or web search can be useful when you are choosing an approach. During implementation, I often want repo-local truth: the current route, the existing form pattern, the test command that already passes. Extra outbound tools can pull the agent away from the files that matter.
If you are building a personal lab, collect away. If you are finishing client work, keep the set small and boring.
### A small starting set (pattern classes only)
I will not give you a ranked “must install these five vendors” list. Vendors change. Auth flows change. What matters is the pattern class and the job it does on a shipping day.
Here are the classes I actually consider for Next.js client work:
#### 1. Repo and project truth
Tools that read or search the systems that already own the work: issue tracker, docs in the company wiki, design notes, or a project board. The goal is fewer tab switches and fewer “wait, what did the ticket say?” moments.
Keep these only if you already use that system day to day. Do not add a board integration for a repo that still runs on Slack threads and a Notion page nobody updates.
#### 2. Docs and API reference
A docs or search helper that can pull current library docs when the model’s training cutoff is the wrong year. Useful for framework APIs, auth libraries, and payment SDKs. Less useful for your own app code. Your app code is in the repo.
#### 3. Browser or preview helpers
Tools that help inspect a running local app, capture a page state, or check a UI path you just changed. Helpful for client-facing Next.js work when the bug is visual or interaction-shaped. Not a replacement for your own click-through.
#### 4. Deployment and observability (optional, later)
Status, logs, or deploy helpers can be useful once the shipping loop is stable. I do not put these in the day-one set. They are high-blast-radius if the agent starts “helpfully” poking production.
#### 5. Domain-specific tools you already trust
Email, Drive, CRM, or CMS adapters only if that product is part of the ticket. A Gmail tool on a pure UI ticket is clutter.
Start with one class that matches this week’s work. Add a second class only after the first one is boring and reliable.
I keep my Cursor habits and ambassador notes on /cursor-ambassador. The point of that page matches this one: practical setup, not a trophy shelf of integrations.
### Wire one then expand
Do not enable five servers and then debug which one broke the agent. Wire one.
My sequence:
- Pick one job. Example: “pull the latest ticket acceptance criteria into chat” or “fetch current Next.js docs for this API.”
- Enable only that server. Leave the rest off.
- Authenticate and run a boring sample call. Prefer a read-only action first.
- Write a short note in the project or personal rules: when to use it, when not to use it.
- Ship one real PR with it in the loop. If it did not help, disable it.
- Only then add the next server.
Verification checklist I actually use:
- Does the server show as connected after restart?
- Does a deliberate tool call succeed?
- Does an unrelated prompt still stay in the repo instead of fishing for tools?
- Do I know how to revoke auth if the client repo should not keep that connection?
If step three fails, fix that server before you touch another. Half-broken MCP is worse than no MCP. The agent will retry, stall, or invent a workaround that looks like progress and is not.
Expanding is allowed. Expanding without a job description is how you get marketplace pile-ons.
### Next.js client work
On Next.js client projects, MCP earns its keep when it shortens the path from ticket to reviewed PR. Typical moments:
- Confirming how an App Router API actually behaves this year, not last year’s blog post.
- Pulling design or acceptance notes into the same chat where you are scoping files.
- Checking a local preview path after a form or navigation change.
- Looking up a library’s current prop names before the agent invents a close-enough version.
Keep the non-MCP basics either way: project rules, a short plan before Composer writes, scoped files, typecheck/lint, and a PR review that assumes the agent is fast and occasionally wrong. If the agent needs six external tools to “understand” your app, your repo context is underfed. Feed the repo first.
For client work, be careful with anything that can touch staging, production, or customer data. Read-only first. Explicit confirmation for writes. No “just sync the CMS” during a UI polish PR.
### Skip list
I skip servers that fail the keep test, even when they look popular.
Skip (or disable later) when:
- Auth is fuzzy. You are not sure which account is connected, or the client repo should not inherit your personal tokens.
- The tool duplicates the repo. Searching your own source through an external wrapper when @ file mentions already work is overhead.
- Every prompt becomes a tool safari. The agent calls three tools before reading the open file.
- The output is noisy. Huge dumps that blow the context window and bury the diff.
- You enabled it “for later.” Later rarely comes. Turn it off until a ticket needs it.
- Write access without a reason. Prefer read-only until you have a repeated, reviewed workflow.
- Marketplace curiosity during a deadline. Curiosity belongs on a sandbox repo, not on the client main branch day.
Also skip ranking lists that treat MCP like a starter pack. Your stack, your ticket queue, and your threat model decide the set. A server that shines for content sites may be dead weight on a gated SaaS dashboard.
Already collected a dozen? Disable all, re-enable the two you used this week, leave the rest off for a month. Most people do not miss them.
If you want help turning Cursor into a shipping habit instead of a settings hobby, that is the Level-up lane I run as Vibe Code Friend. We tighten MCP, rules, and review loops on your real repo so the agent stays useful when the PR still has to land.
---
## PHP API development for a Next.js product
URL: https://madebyaris.com/blog/php-api-development-for-nextjs
Published: 2026-09-14. Updated: 2026-09-24.
PHP API development for a Next.js product is not “put JSON in a controller and hope.”
I put the write where the domain already lives. Laravel (or modern PHP) owns auth, validation, the database write, and the job queue. Next.js owns the UI and the cache that shows that write. If I cannot name who owns the write, I do not open a new endpoint.
I already wrote the App Router API routes I trust. This post is the other door: when the API is PHP, not another route.ts in the same repo.
If you want this owned on a product, that is PHP development.
### Who owns the write
A Next.js form can look like it owns everything. It does not.
Next.js. Collect input. Call the API. Revalidate the tag the list page uses. Show the result. Keep Server Actions for writes that never leave this app. When the domain is already PHP, the form is a client of that API.
PHP API. Authenticate. Validate. Write once. Enqueue the slow work. Return a boring status and a small JSON body. Prefer Laravel when the product already has models, policies, and jobs there. I do not invent a second domain layer in Next to look modern.
Database. One writer path. If Next and PHP both write the same table “for speed,” you will debug race conditions on a Friday.
The split is the product. A pretty React form with a half-auth PHP dump behind it is not PHP API development. It is a leak.
### When I keep Laravel behind Next.js
I keep Laravel (or a focused PHP API) when one of these is true:
The business rules already live in PHP. Orders, invoices, roles, reports. Rewriting that into TypeScript just to say “all Next” is a year of unpaid migration.
You need a real job queue. Emails, PDF, webhooks to vendors, retries. Laravel queues are boring and shippable. I do not fake that with a route.ts that times out at 30 seconds.
Multiple clients need the same write. A Next app, a mobile app, an admin tool. One versioned HTTP contract. Not three copies of the same validation.
You are modernizing a legacy PHP app and the UI is moving to Next first. Keep the write in PHP. Move screens. Do not dual-write.
I still use Next for the App Router tree, the cache I can name, and the hire path on Next.js development when the product is mostly that stack. This post is for the case where PHP is the API owner.
### A contract I will ship
A PHP API endpoint I will leave in the repo looks boring on purpose.
Auth first. Session cookie for first-party, token for third-party, signature for webhooks. Fail closed. I do not return 200 on a bad signature so a vendor “stops retrying.”
One job. Create invoice. Update status. Enqueue PDF. If the handler also rewrites three tables and pings Slack, I split it. The HTTP response stays small.
Versioned path. /api/v1/... when an outside client exists. Breaking changes get a new version. I do not silently rename fields because the Next form was updated this morning.
Named errors. validation_failed, unauthorized, conflict. Not a stack dump. Not a blank 500.
Docs that match the code. Even a short OpenAPI or a Markdown table of routes. If the Next app guesses field names, the contract is already broken.
What I skip:
A god endpoint that accepts action=anything.
Leaking SQL or stack traces to the browser.
Skipping auth because “it is only called from our Next app.” Your Next app is still the internet.
Duplicating the same write as a Next Server Action and a PHP route “just in case.” Pick one owner.
### How Next.js talks to it
From the Next side I keep the call boring too.
Server-side fetch to the PHP origin with the auth the API expects. Timeout I can name. Parse JSON. Map named errors to UI. After a successful write, revalidate the tag the list page uses. Same cache habit as Next.js cache on Vercel.
I do not put the PHP database password in the Next env “to skip the API.” That is how you get two writers and one outage.
For webhooks that hit PHP, Next stays out of the path. For webhooks that must touch a Next-only cache, PHP finishes the write, then a small internal call or a shared tag strategy busts what the UI shows. Name that path. Do not invent it in production.
### What I will take
I take a Next.js product that needs a real PHP or Laravel API: auth, writes, jobs, a versioned contract, and a UI that does not own the database. I also take legacy PHP with a new Next front when we keep one writer.
I will not take a rewrite that turns every Laravel policy into a Server Action so the stack looks uniform on a slide.
If you want this owned, start at PHP development. Send the repo or the ticket. If the front is the main gap and the API is already fine, say so. We will pick the door that matches the write.
---
## Cursor AI Indonesia: how I teach teams to ship with AI
URL: https://madebyaris.com/blog/cursor-ai-indonesia
Published: 2026-09-08. Updated: 2026-09-08.
Cursor AI Indonesia, for me, is not a feature tour. It is teaching teams a shipping practice they can repeat on Monday without me in the room.
I get asked for demos of Chat, Composer, and whatever shipped last week. Those demos look fine. They do not stick. The team still pastes a vague prompt, merges a diff nobody read, and calls it AI adoption. I want the opposite: one real repo, a short project rule, a review habit, and a stop when the loop is owned.
I’m Aris Setiawan. I run madebyaris from Sidoarjo, Indonesia. I have been shipping web work for 13+ years. I was the first Cursor Ambassador in Indonesia, and after SpaceXAI acquired Cursor I am a SpaceXAI ambassador. I am also a MiniMax Dev Community Expert. I teach Cursor workflows. This URL is Level up mentoring.
If you want the deeper how-to on the editor itself, start with my Cursor AI workflow for production. This post is the door: how I teach teams here, and where that teaching lives on the site.
### What I teach
I do not start with a slide of every button. I start with four named steps. If a session cannot name those four by the end, we did not teach. We performed.
I have sat with teams that already bought seats and still shipped the same vague prompts. The fix was never another shortcut cheat sheet. It was putting one ticket on a real branch and refusing to move on until the review habit showed up in the PR.
One real repo. Not a toy sandbox. The product they already ship, or the next ticket on that product. If the practice never touches the real tree, it will not survive the first busy week.
Project rules. One short rule checked into the repo. What the agent may touch. What it must not invent. How we name a stop. I have written about project rules elsewhere. Here the point is simpler: a rule the team can point at when a diff goes sideways.
Review the diff. Before merge. File by file. Leftover util, second type file, a folder that does not exist elsewhere. Same instinct as a careful PR review. The model proposed. A human still owns the merge.
Stop when the loop is owned. The goal is not “more AI.” The goal is a team that can open a ticket, set the context, read the result, and ship without waiting for another workshop.
That is the whole loop. One repo. One rule. One review habit. I repeat it until someone on the team can teach it back without reading my notes.
I do not grade people on how many features they can name. I grade the first PR after the session. If the rule is ignored and the diff is unread, we schedule another pass on the same loop. We do not add a fifth shiny tool to cover the gap.
### What I refuse
This is the part that keeps Cursor AI Indonesia from turning into theater.
Tool dump workshops. A two-hour tour of every panel is entertainment. It is not a practice. If the session ends and nobody can name the rule or the review step, we wasted the afternoon.
Blending mentoring with Build hire. Level up is mentoring. Build is product work on a different door. I do not sell a hire inside a teaching session, and I do not pretend mentoring is a free scoping call for a build. Different offers. Different URLs.
Metric theater. I will not invent student counts, team sizes, or case studies to make this page look louder. If I cannot name the proof, I leave the number out.
I also refuse to chase every new model announcement as the curriculum. Models change. The shipping loop does not. Teach the loop first.
### The Level up door
This URL exists so people searching Cursor AI Indonesia find a mentoring path, not another generic how-to stacked on top of the pillar.
The commercial door is Vibe Code Friend. That is Level up: Cursor mentoring, workflows, the practice above. If you want product builds (Next.js, WordPress, AI wiring), that is a different offer on a different page. I keep them apart on purpose.
I also keep a public note on the ambassador path at Cursor Ambassador. Useful context. Not a substitute for the mentoring door.
If your team is in Indonesia, or remote and shipping with Cursor, and you want the practice owned, start at Vibe Code Friend. Bring one real repo and the ticket you care about. We will set the rule, review the first diffs together, and stop when your team can run the loop without me.
For the editor-side craft, keep Cursor AI workflow for production open next to this page. This one is the door. That one is the practice depth.
---
## Practical AI Agent Development for Production
URL: https://madebyaris.com/blog/ai-agent-development
Published: 2026-09-04. Updated: 2026-09-24.
AI agent development that has to live in production is not a loop that can call anything. It is one job a user can name, a short list of tools your code owns, and a stop rule before the bill or the blast radius gets weird.
I have shipped the science fair version. An agent with twenty tools, no step cap, and a prompt that said “be helpful.” It looked clever in a demo. It stalled on the first real ticket that needed a write, a refund, or a private row. Then someone asked why the model was calling tools we never reviewed.
I already wrote AI chatbot development that fits a real Next.js app, AI integration services: what to scope before you buy, and the API routes I trust. This post is AI agent development when the agent has to sit in that same product, not on a slide.
The offer page is Hire an AI developer.
### Scope the agent first
I do not start with a framework. I start with three names on a page.
Job. What one outcome does the user get? Summarize this ticket. Draft a reply from these docs. Find the order and open a support case. If you need three outcomes, that is three agents or one agent with three explicit modes. “Help with ops” is not a job.
Tools. Which functions can it call? getOrder. searchDocs. createTicket. Each one has a schema, an auth check in your handler, and a reason it exists. I do not expose “run any SQL” or “call any internal API” because the model sounded confident in a walkthrough.
Stop. Max steps. Max tokens. When a human must review before a write. An agent without a stop is a cost and an incident waiting for a fuzzy prompt. I write the stop in the same brief as the job.
If those three are blank, I do not build. Chat without tools is still fine. An unbounded agent is not progress. It is surface area.
### Model proposes. Code runs.
The loop I trust is boring on purpose.
The user sends a message into your route. The model proposes a tool call. Your handler checks auth, runs the tool, and returns the result. The model may propose again. You cap the rounds. The UI streams what the user needs to see.
The model never holds the database client. The model never holds the production key. The model never “just” calls a sibling service because the prompt asked nicely. Your code runs the tool. That is the whole product boundary.
I keep the agent next to the same App Router tree I use for chat. One POST owns the session. Tools live as named functions with schemas. Logs keep every proposal and every result. When something goes wrong, I want a line I can read, not a mystery in a vendor dashboard.
A tiny sketch of the shape:
```
// app/api/agent/route.ts
export async function POST(req: Request) {
const session = await auth();
if (!session?.user) {
return new Response("Unauthorized", { status: 401 });
}
const { messages } = await req.json();
// stream with a short tool list + maxSteps
// each tool handler checks session.user again
}
```
The framework can change. The rule does not: propose in the model, run in your code, stop when the budget says stop.
### What I refuse
This is the part demos skip.
Unbounded tools. If the agent can call everything the signed-in user can call, you did not design an agent. You wrapped a confused admin panel in a prompt. Start with read tools. Add write tools only when the blast radius fits in one sentence.
Client keys. The browser does not hold the model key. The agent route fails closed without a session when the data is private. Rate limit per user. Same rules as the chatbot post.
Science-fair demos in prod. A weekend agent that emails customers, refunds orders, or edits CRM rows with no owner and no step cap is not a launch. It is a pager. Keep demos on a branch or a staging project with fake data.
No owner. Someone on your team owns who the agent acts as, which tools are live, and what happens when a tool fails. If that person is “the model,” you do not have an owner.
Cost without a cap is the quiet version of the same refuse list. Max steps. A cheaper model for routing. The hard model only for the final answer when you actually need it. Put those numbers next to the job, not in a post-launch surprise.
### What I skip
I skip a custom model when retrieval plus a short tool list will do. Most product agents need your docs, your orders, your tickets. They need clean tools and a prompt that names the job.
I skip blending this with Cursor mentoring. Different offer. Different URL. This post is Build: wiring an agent into the product you ship.
I skip promising autonomy as the success metric. Correct, bounded, and cheap enough beats a long loop that sounds smart and writes the wrong row.
I skip a second hire page on this keyword. The commercial door stays Hire an AI developer. This URL is the practice page for AI agent development.
### What I will take
I will take an existing Next.js app with auth already shipping, and a one-page brief that names the job, the tool list, and the stop. We ship read tools first. We put writes behind a review or a tight schema. We log every call.
I will take a demo agent that needs to become a product. Pull the key out of the client. Cut the tool list. Add maxSteps. Move the handlers behind the session. That week usually beats another framework bake-off.
If that is the ticket on your desk, the door is Hire an AI developer. Send the job, the tools, and the stop. I will tell you what I would wire first.
---
## AI integration services: what to scope before you buy
URL: https://madebyaris.com/blog/ai-integration-services
Published: 2026-09-03. Updated: 2026-10-25.
API call. Your server posts a prompt, gets a completion, returns it to your UI. Fine for classify, summarize, draft. You own auth, rate limits, and logging. The model is a dependency, not a product surface.
Embedded widget. A chat or assist panel inside your app. Still your route. Still your key on the server. The widget is chrome. The product is the route that checks the session and calls the model. I already wrote how I wire that for chatbot work in Next.js.
Agent with tools. The model can call named functions: getOrder, searchDocs, createTicket. Each tool has a schema and an auth check in your code. The model proposes. Your handler runs. This is powerful and expensive when unbounded. Cap the steps. Log every call.
I pick the smallest shape that does the job. An agent is not a badge of seriousness. It is more surface area. If a single API call drafts the email and a human sends it, that is often the right integration.
When a pitch says “generative AI platform” and cannot say which of those three shapes they will leave in your repo, I treat it as a workshop, not a build.
### What I refuse in the SOW
This is the part demos skip.
Open proxy key. If the browser holds the model key, or if anyone can hit your chat route without a session, you did not buy an integration. You bought a shared wallet. Key on the server. Auth on the route. Rate limit per user.
Unbounded tools. An agent that can call anything the signed-in user can call, with no step cap and no review, is not a feature. It is an incident waiting for a confused prompt. Read tools first. Write tools only when the blast radius is named.
No auth owner. Someone on your side owns who the model acts as. Session user. Service account. Impersonation rules. If the vendor “handles auth later,” the integration is not scoped.
Vendor owns your data path. If the only way to reach your docs or orders is through their black box, and you cannot export or replace the connector, you are renting a hostage. Prefer your route calling their model API (or yours) with your retrieval. Keep the data boundary in code you can open.
Cost without a cap is the quiet version of the same refuse list. Messages per user per day. Max steps. A cheaper model for routing when the hard model is only needed for the final answer. Put those in the SOW, not in a post-launch surprise.
### What I skip
I skip a custom model when retrieval plus tools will do. Most product integrations need your docs, your orders, your tickets. They need clean tools and a prompt that names the job. Fine-tuning is a later problem.
I skip “AI strategy” decks that never name a surface. Strategy without a screen is a workshop invoice.
I skip blending this with Cursor mentoring or a vibe-code pitch. Different offer. Different URL. This post is Build: wiring AI into the product you ship.
I skip promising “human-like” copy as the success metric. Correct, bounded, and fast enough beats charming and wrong.
I skip a second URL for “generative AI integration services.” Same scoping job. Same three names. One post.
### What I will take
I will take an existing Next.js (or similar) app with auth already shipping, and a one-page brief that names surface, data, and write path. We pick the smallest shape. We put the key on the server. We ship behind the signed-in wall first when the data is private.
I will take a vendor demo that needs to become a product. Pull the key out of the client. Move the call into your route. Replace stub tools with handlers that check the user. That week is usually worth more than another bake-off.
If that is the ticket on your desk, the door is Hire an AI developer. Send the surface, the data boundary, and what the model is allowed to write. I will tell you what I would scope first.
Surface. Where does the AI show up for a real user? A support panel. An admin helper. A draft button on a form. A background job that never hits the UI. If you cannot point at a screen or a job, you are buying a demo, not an integration.
Data. What can the model read? Product docs. Orders for the signed-in user. Ticket history. A private knowledge base. Name the sources and the auth boundary. “All our data” is not a source. It is how you get a leak and a surprise bill in the same week.
Write path. What can it change? Create a ticket. Update a draft. Trigger an email. Nothing. Read-only is a valid answer. Write tools without a named blast radius are how a helpful bot rewrites production rows because a prompt was fuzzy.
If those three are blank, I push the SOW back. Generative AI integration into an existing product is the same three questions with a longer answer on the write path. The model still needs a surface, a data boundary, and a list of mutations you can defend.
### Pick the shape, not the logo
Vendors sell logos. I buy a shape.
API call. Your server posts a prompt, gets a completion, returns it to your UI. Fine for classify, summarize, draft. You own auth, rate limits, and logging. The model is a dependency, not a product surface.
Embedded widget. A chat or assist panel inside your app. Still your route. Still your key on the server. The widget is chrome. The product is the route that checks the session and calls the model. I already wrote how I wire that for chatbot work in Next.js.
Agent with tools. The model can call named functions: getOrder, searchDocs, createTicket. Each tool has a schema and an auth check in your code. The model proposes. Your handler runs. This is powerful and expensive when unbounded. Cap the steps. Log every call.
I pick the smallest shape that does the job. An agent is not a badge of seriousness. It is more surface area. If a single API call drafts the email and a human sends it, that is often the right integration.
When a pitch says “generative AI platform” and cannot say which of those three shapes they will leave in your repo, I treat it as a workshop, not a build.
### What I refuse in the SOW
This is the part demos skip.
Open proxy key. If the browser holds the model key, or if anyone can hit your chat route without a session, you did not buy an integration. You bought a shared wallet. Key on the server. Auth on the route. Rate limit per user.
Unbounded tools. An agent that can call anything the signed-in user can call, with no step cap and no review, is not a feature. It is an incident waiting for a confused prompt. Read tools first. Write tools only when the blast radius is named.
No auth owner. Someone on your side owns who the model acts as. Session user. Service account. Impersonation rules. If the vendor “handles auth later,” the integration is not scoped.
Vendor owns your data path. If the only way to reach your docs or orders is through their black box, and you cannot export or replace the connector, you are renting a hostage. Prefer your route calling their model API (or yours) with your retrieval. Keep the data boundary in code you can open.
Cost without a cap is the quiet version of the same refuse list. Messages per user per day. Max steps. A cheaper model for routing when the hard model is only needed for the final answer. Put those in the SOW, not in a post-launch surprise.
### What I skip
I skip a custom model when retrieval plus tools will do. Most product integrations need your docs, your orders, your tickets. They need clean tools and a prompt that names the job. Fine-tuning is a later problem.
I skip “AI strategy” decks that never name a surface. Strategy without a screen is a workshop invoice.
I skip blending this with Cursor mentoring or a vibe-code pitch. Different offer. Different URL. This post is Build: wiring AI into the product you ship.
I skip promising “human-like” copy as the success metric. Correct, bounded, and fast enough beats charming and wrong.
I skip a second URL for “generative AI integration services.” Same scoping job. Same three names. One post.
### What I will take
I will take an existing Next.js (or similar) app with auth already shipping, and a one-page brief that names surface, data, and write path. We pick the smallest shape. We put the key on the server. We ship behind the signed-in wall first when the data is private.
I will take a vendor demo that needs to become a product. Pull the key out of the client. Move the call into your route. Replace stub tools with handlers that check the user. That week is usually worth more than another bake-off.
If that is the ticket on your desk, the door is Hire an AI developer. Send the surface, the data boundary, and what the model is allowed to write. I will tell you what I would scope first.
AI integration services that are worth the invoice start with a scope you can say out loud. Not a model brand. Not a slide that says “AI-powered.” The surface where the model shows up, the data it is allowed to read, and the write path it is allowed to touch.
I have sat on both sides of that SOW. Buyer who wanted “some AI in the product.” Seller who got handed a vague brief and a deadline. The projects that stayed maintainable named those three early. The ones that turned into a science fair did not.
I already wrote AI chatbot development that fits a real Next.js app, the API routes I trust, and the cache I set on Vercel. This post is what I ask when someone wants to buy AI integration services into an existing product.
The offer page is Hire an AI developer.
### Name these three before the kickoff
I do not start with a vendor shortlist. I start with three names on a page.
Surface. Where does the AI show up for a real user? A support panel. An admin helper. A draft button on a form. A background job that never hits the UI. If you cannot point at a screen or a job, you are buying a demo, not an integration.
Data. What can the model read? Product docs. Orders for the signed-in user. Ticket history. A private knowledge base. Name the sources and the auth boundary. “All our data” is not a source. It is how you get a leak and a surprise bill in the same week.
Write path. What can it change? Create a ticket. Update a draft. Trigger an email. Nothing. Read-only is a valid answer. Write tools without a named blast radius are how a helpful bot rewrites production rows because a prompt was fuzzy.
If those three are blank, I push the SOW back. Generative AI integration into an existing product is the same three questions with a longer answer on the write path. The model still needs a surface, a data boundary, and a list of mutations you can defend.
### Pick the shape, not the logo
Vendors sell logos. I buy a shape.
API call. Your server posts a prompt, gets a completion, returns it to your UI. Fine for classify, summarize, draft. You own auth, rate limits, and logging. The model is a dependency, not a product surface.
Embedded widget. A chat or assist panel inside your app. Still your route. Still your key on the server. The widget is chrome. The product is the route that checks the session and calls the model. I already wrote how I wire that for chatbot work in Next.js.
Agent with tools. The model can call named functions: getOrder, searchDocs, createTicket. Each tool has a schema and an auth check in your code. The model proposes. Your handler runs. This is powerful and expensive when unbounded. Cap the steps. Log every call.
I pick the smallest shape that does the job. An agent is not a badge of seriousness. It is more surface area. If a single API call drafts the email and a human sends it, that is often the right integration.
When a pitch says “generative AI platform” and cannot say which of those three shapes they will leave in your repo, I treat it as a workshop, not a build.
### What I refuse in the SOW
This is the part demos skip.
Open proxy key. If the browser holds the model key, or if anyone can hit your chat route without a session, you did not buy an integration. You bought a shared wallet. Key on the server. Auth on the route. Rate limit per user.
Unbounded tools. An agent that can call anything the signed-in user can call, with no step cap and no review, is not a feature. It is an incident waiting for a confused prompt. Read tools first. Write tools only when the blast radius is named.
No auth owner. Someone on your side owns who the model acts as. Session user. Service account. Impersonation rules. If the vendor “handles auth later,” the integration is not scoped.
Vendor owns your data path. If the only way to reach your docs or orders is through their black box, and you cannot export or replace the connector, you are renting a hostage. Prefer your route calling their model API (or yours) with your retrieval. Keep the data boundary in code you can open.
Cost without a cap is the quiet version of the same refuse list. Messages per user per day. Max steps. A cheaper model for routing when the hard model is only needed for the final answer. Put those in the SOW, not in a post-launch surprise.
### What I skip
I skip a custom model when retrieval plus tools will do. Most product integrations need your docs, your orders, your tickets. They need clean tools and a prompt that names the job. Fine-tuning is a later problem.
I skip “AI strategy” decks that never name a surface. Strategy without a screen is a workshop invoice.
I skip blending this with Cursor mentoring or a vibe-code pitch. Different offer. Different URL. This post is Build: wiring AI into the product you ship.
I skip promising “human-like” copy as the success metric. Correct, bounded, and fast enough beats charming and wrong.
I skip a second URL for “generative AI integration services.” Same scoping job. Same three names. One post.
### What I will take
I will take an existing Next.js (or similar) app with auth already shipping, and a one-page brief that names surface, data, and write path. We pick the smallest shape. We put the key on the server. We ship behind the signed-in wall first when the data is private.
I will take a vendor demo that needs to become a product. Pull the key out of the client. Move the call into your route. Replace stub tools with handlers that check the user. That week is usually worth more than another bake-off.
If that is the ticket on your desk, the door is Hire an AI developer. Send the surface, the data boundary, and what the model is allowed to write. I will tell you what I would scope first.
---
## How I check ranks after I ship
URL: https://madebyaris.com/blog/how-i-check-ranks-after-i-ship
Published: 2026-09-02. Updated: 2026-10-24.
I check ranks after publish the next morning, not the minute the URL is live.
Ship day is indexing. Morning is Overview, then Keywords. I want a stored series, not a screenshot that dies when I close the tab.
I’m Aris Setiawan. I ship Next.js and I built RankMySEO SaaS so a rank check has somewhere to live. The product intro is Introducing RankMySEO SaaS. Hosted vs self-hosted is RankMySEO SaaS vs open source. Open beta is the week of 31 Aug 2026. Not billed.
Ship day, then morning
### The day the URL goes live
I do not treat first paint as a rank day.
I ship the URL. I request indexing. I attach the URL and the focus phrase to the RankMySEO project if they are not already there. I can queue a background check so there is a first stored snapshot. I do not sit on the board and wait for Google to already rank it.
A one-shot lookup on ship day is not a baseline I can defend tomorrow. If the page is new, empty SERP history is normal. I leave.
### Next morning: Overview, then Keywords
Morning is when I check ranks after publish for real.
Overview first. That is the project home. I want movement that already landed in history, not a live peek that disappears when I close the tab. RankMySEO SaaS runs rank checks in the background. The board stays usable. Results stick with the project.
Then Keywords. That is the focus phrase work. Daily SERP for the keywords on that project. I look at the phrase I shipped for, not a dashboard of vanity totals.
I do not invent a position. I read what we stored. If there is still nothing, I wait another day. That is still the loop.
Overview first, Keywords second
### Why a one-shot lookup is not enough
A one-shot lookup answers what it looks like right now. It does not answer what changed.
SEO arguments die on that gap. Someone pastes a screenshot. Someone else pastes a different screenshot. Nobody owns yesterday.
RankMySEO SaaS exists so Overview and Keywords read stored history. Open beta this week. No Stripe. I am not selling a rank number. I am keeping a time series.
If you want to run the stack yourself, the OSS path is github.com/madebyaris/rankmyseo. The comparison lives in the SaaS vs open source post. Same family name, different job.
### Short first-week loop
Day 0: live URL, indexing request, optional first queued check. I do not score it.
Day 1: Overview, then Keywords. Read stored ranks. Note the focus phrase only.
Days 2 to 7: let daily SERP write history. Open the board when I ship a change, not every hour. Background checks do the waiting. I do not refresh a one-shot tool hoping it will tell a better story.
End of week: I have a short series or I still have gaps. Gaps are data. A screenshot with no date is not.
That is how I check ranks after I ship. History first. Then I decide what to change.
To get this loop set up on your site, read about my technical SEO work.
---
## RankMySEO is live (open beta)
URL: https://madebyaris.com/blog/rankmyseo-is-live-open-beta
Published: 2026-09-02. Updated: 2026-10-24.
RankMySEO open beta is live this week of 31 Aug 2026. The hosted MVP is clickable: Overview, Keywords, background rank checks, and history that stays on the project.
It is not billed. There is no Stripe. I already wrote the product intro. This post is only what you can use now.
I built RankMySEO so a rank check has somewhere to live after I close the tab.
### What you can click today
I am not rewriting the RankMySEO SaaS intro. That post is the product story. This one is the board that is open this week.
I open a project. Overview is the home screen. I get a read on how keywords are doing without jumping around.
Keywords is the day-to-day list. I attach keywords to that project. Daily SERP stays with it so I can look back instead of guessing.
Check ranks queues the work in the background. The board stays usable. I come back to results in history, not a spinner that owns the page.
That is the hosted MVP: history that sticks. Tomorrow I can still see yesterday.
### What is not in this beta
No public paid billing. No Stripe. I am not inventing a signup URL, a seat count, or a public app domain here. If you want the product story, use the intro. If you want early access, watch the site or reach out through services.
I would rather say that plainly than dress an MVP as a launch with a price.
### Hosted beta vs the OSS toolkit
The hosted product is the clickable board. The OSS toolkit is github.com/madebyaris/rankmyseo.
Same family name, different job. Use hosted if you want the UI and stored history. Use the public toolkit if you want packages in your repo. Some people will use both.
The competitor matrix lives on RankMySEO SaaS vs open source. I am not rebuilding it here.
### What I want you to do
If you have been waiting for RankMySEO open beta, it is this week. Click what exists. Do not wait for billing.
If you want the hosted board, start from the intro and contact me through my SEO services page. If you want the toolkit, use the public repo and skip the wait.
I will take people who want the hosted board this week, or who want the toolkit in their repo. I will not take a wait for billing that does not exist yet.
---
## AI chatbot development that fits a real Next.js app
URL: https://madebyaris.com/blog/ai-chatbot-development
Published: 2026-09-02. Updated: 2026-10-25.
AI chatbot development that has to live in a real Next.js app is not a chat demo. It is a route that owns the request, a stream the UI can follow, and tools the model can call without turning your app into an open proxy.
I have shipped the cute widget. A floating bubble. A third-party iframe. A key sitting in the browser because the tutorial said so. It looked finished in a walkthrough. It broke the first week someone asked the bot for something that touched a real order, a real user, or a real bill.
I already wrote the App Router I keep in `app/`, the API routes I trust, and the cache I set on Vercel. This post is AI chatbot development when the bot has to sit in that same tree.
The offer page is Hire an AI developer.
### What I wire first
I do not start with a model picker. I start with three named pieces: the route, the stream, and the tools.
Route. There is one POST that owns the chat. Usually app/api/chat/route.ts. That file reads the session, checks the user, and calls the model. I do not leave a public endpoint that any visitor can hammer with my key. If the chat is only for signed-in people, the route fails closed before a single token leaves.
Stream. I stream tokens out as they land. The user sees the answer grow. Waiting on a full JSON blob for a long reply feels broken even when the model is fine. With the Vercel AI SDK that is the normal path: the route returns a stream, the client renders it. I do not invent a second polling loop because streaming felt hard on day one.
Tools. Function calls are how the bot touches your app. getOrder. searchDocs. createTicket. Each tool has a name, a schema, and an auth check inside the handler. The model proposes the call. My code runs it. I do not hand the model a raw database client and hope.
Those three are the product. The model brand is a swap. OpenAI today, Anthropic tomorrow, something else next year. The route, the stream, and the tool list stay.
A short sketch of the route shape I keep coming back to:
```
// app/api/chat/route.ts
export async function POST(req: Request) {
const session = await auth();
if (!session?.user) {
return new Response("Unauthorized", { status: 401 });
}
const { messages } = await req.json();
const result = streamText({
model,
messages,
tools: {
getOrder: {
description: "Fetch one order for the signed-in user",
parameters: orderSchema,
execute: async ({ id }) => getOrderForUser(session.user.id, id),
},
},
maxSteps: 3,
});
return result.toDataStreamResponse();
}
```
That is not a full product. It is the spine. Auth first. Tools that know the user. A step cap so the model cannot loop forever.
### Where the bot lives in the App Router
People ask where the chat “should” live. Server Action, route handler, or a fat client component. I pick based on what the request needs to do.
Server Action when the chat is basically a form. Short prompt, one reply, same session, no need for a public URL. Fine for an internal admin helper. Awkward when you want a proper streaming UX or an external client calling in.
Route Handler when the chat is a product surface. Streaming POST. Mobile client. Another service posting into the same handler. This is my default for AI chatbot development inside a Next.js app. Same rules I already use for API routes: the handler owns auth, validation, and what leaves the server.
Client island for the UI only. The React tree that holds messages, the input, the scroll. It calls the route. It never holds the model key. NEXT_PUBLIC_ and an LLM secret do not belong in the same sentence.
I do not put the whole bot in a client component “so it feels faster.” The network hop to your own route is cheap. Leaking the key is not.
If the page that hosts the chat also needs fresh user data, I keep that fetch on no-store the same way I do for any session page. Chat and cache stay in the same conversation: public marketing can be static; the signed-in chat shell is not.
### Auth, cost, and what I refuse to ship
This is the part demos skip.
No open proxy. If anyone on the internet can POST to your chat route and burn tokens on your bill, you did not ship a chatbot. You shipped a shared wallet. Auth on the route. Rate limit per user. I would rather return 401 than explain a surprise invoice.
No unbounded tool loop. Tools are powerful. They are also a way for a confused model to call searchDocs forty times. I set maxSteps (or the equivalent) low. I log every tool call. If a tool fails, I return a clear error to the model once. I do not let it retry in a dark loop while the meter runs.
No secret in the client. The API key lives on the server. Full stop. I have inherited apps where the key sat in a client bundle “just for the prototype.” Prototypes go to production. The key goes with them. Move it to the route before you show the bubble to a customer.
Cost is a product decision, not an afterthought. I cap messages per user per day when the use case allows it. I trim history instead of sending the whole thread on every turn. I pick a cheaper model for classification and tool routing when the hard model is only needed for the final answer. None of that is fancy. It is how you keep AI chatbot development from becoming a monthly surprise.
I also refuse to ship a bot that can write anywhere the signed-in user can write, with no review. Read tools first. Write tools only when the blast radius is named. Same instinct as a careful Server Action: know what the call can touch.
### What I skip
I skip the floating bubble on day one if the product does not need it. A chat page at /support or a panel inside the dashboard is enough. The bubble is chrome.
I skip training a custom model when retrieval plus tools will do. Most product chatbots need your docs, your orders, your tickets. They do not need a fine-tune. They need clean tools and a prompt that names the job.
I skip storing every raw completion forever “for later.” Keep what you need for support and debugging. Drop the rest. Logs without a retention plan become a second product.
I skip blending this with Cursor mentoring or a “vibe code” pitch. Different offer. Different URL. This post is Build: the bot inside the Next.js app you ship.
I skip promising “human-like” copy in the marketing line. The bot should be correct, fast enough, and bounded. Personality is optional. Wrong answers with a friendly tone still burn trust.
### What I will take
I will take a Next.js app that already has auth and a real domain object the bot should touch. Orders. Docs. Tickets. Accounts. We wire the route, the stream, and two or three tools. We put a cap on steps and spend. We ship behind the signed-in wall first.
I will take a demo that needs to become a product. Pull the key out of the client. Move the call into route.ts. Replace the fake tool stubs with handlers that check the user. That week of work is usually worth more than another model bake-off.
If that is the ticket on your desk, the door is Hire an AI developer. Send the repo shape and what the bot is allowed to do. I will tell you what I would wire first.
---
## SEO Metadata in Next.js App Router Done Right
URL: https://madebyaris.com/blog/seo-metadata-in-nextjs-app-router
Published: 2026-08-31. Updated: 2026-09-24.
I set SEO metadata once in Next.js App Router. metadata or generateMetadata on the page that owns the URL. The layout holds the default. The page overrides. Titles do not double.
That is the whole job. Not a second in the layout JSX. Not the brand name pasted into every page.
I already wrote the App Router I keep in `app/`, when I still touch Pages, the API routes I trust, and how I migrate without drama. This post is SEO in Next.js App Router: titles, Open Graph, and the concatenate bug I still inherit.
The offer page is Hire a Next.js developer. If the ticket is metadata, titles, and crawl, that is also the Next.js SEO work. This is the practice, not an audit brochure.
### Set it once on the page that owns the URL
A route gets one title. I write it on the file that is that URL.
Static page: export const metadata. Dynamic page: generateMetadata. I do not do both. I do not also drop a tag in the layout so “it shows in view source.”
The layout can hold a default description, a default Open Graph image, a metadataBase. Those are fallbacks. They are not the post title.
If I cannot point at the object that produced the tab title, I am not done. Same rule I use for cache on Vercel: name the thing, or do not ship.
### Root layout is the default, not the title
app/layout.tsx is where I put the site name as a default. Not as the page title.
```
export const metadata = {
metadataBase: new URL("https://madebyaris.com"),
title: {
default: "Madebyaris",
template: "%s | Madebyaris",
},
description: "Next.js, WordPress, and AI product work.",
};
```
default is what a route uses when it does not set a title. template is the suffix. The page passes the %s. I do not put the suffix in the page title as well.
A nested app/blog/layout.tsx does not get its own title: "Blog". That is how “Post | Blog | Madebyaris” is born. The blog layout can set a default description for the section. The post still owns the title.
This is the bug. Layout title as a string. Nested layout title as a string. Page title already including the brand. Next merges them. The tab reads “Post | Madebyaris | Blog | Madebyaris”. Google gets that string too.
I have shipped that. I have inherited it on a marketing site where every H1 looked fine and every tab looked drunk. The fix is not a unique title in four files. The fix is one default, one template, one page title.
### title.template vs absolute
Most routes want the suffix. A hire page, a home page, a campaign URL often does not.
Template: the page sets title: "App Router". The tab is App Router | Madebyaris. That is what I want on a blog post.
Absolute: the page sets title: { absolute: "Hire a Next.js developer" }. The template is skipped. The tab is exactly that string. I use this when the URL is the offer, not a child of the brand.
I do not fight the template by stuffing the full branded title into every page. That is how you get the brand twice. If the suffix is wrong for this URL, I use absolute. I do not delete the template from the root layout so one landing page looks clean.
### generateMetadata for a dynamic route
A [slug] page cannot hardcode a title. I load the record, then I return one object.
```
export async function generateMetadata({ params }) {
const { slug } = await params;
const post = await getPost(slug);
if (!post) return { title: "Not found" };
return {
title: post.title,
description: post.excerpt,
openGraph: {
title: post.title,
description: post.excerpt,
images: post.cover ? [{ url: post.cover }] : undefined,
},
};
}
```
The title is the post title. The template in the root layout adds the site name. I do not return post.title + " | Madebyaris". That is the concatenate bug with extra typing.
If the fetch is the same one the page uses, I share the helper. I do not fetch twice with two cache stories. I already wrote how I wire a headless WordPress front: REST, a tag, the slug as the key. generateMetadata uses that same helper.
A missing post gets a small title and the page returns 404. I do not invent “Untitled” so the function always returns something pretty.
### Open Graph from the same object
Open Graph is not a second metadata system. It is fields on the same return.
openGraph.title matches title unless I have a reason it should not. Same for description. The image is one URL, absolute, via metadataBase or a full string. I do not leave a relative /og.png and hope the crawler knows the host.
I set twitter.card when I care about the card. I do not copy the whole Open Graph tree into a Twitter object “for completeness.” If the image is missing, I let the layout default show. A broken og:image is worse than the site default.
Canonical is the public URL. On this site that is madebyaris.com, not the WordPress CMS host. If I ship the CMS URL as canonical, I have told Google the wrong owner.
### What I skip
A in layout.tsx plus an exported metadata object. One of them will win. I will not remember which on a Friday.
next/head on an App Router page. That is Pages habit. Metadata lives in the export.
A client layout so I can usePathname a title. The title is a server field. If the document title has to change after a click, I still start from the server object.
Four nested layouts that each set title. The innermost page should be the only one naming the URL.
A unique description that is the title copied twice. Description is the sentence under the link. I write it like the excerpt: what the page is, in one breath.
### What I will take
I take a Next.js App Router app whose tab titles I can explain. Show me the root metadata, the template, and the page or generateMetadata that fills %s. I will also take the messy case: doubled titles, a CMS slug in the canonical, Open Graph pointing at localhost, a blog layout that keeps adding “Blog” to every post.
I will not take a rewrite that sprinkles next/head through client components so “SEO is covered.”
If you want this owned on your product, that is the work on Hire a Next.js developer. Metadata, titles, and crawl sit with the Next.js SEO support page. Send the repo or the ticket.
---
## Next.js cache on Vercel: what I change first
URL: https://madebyaris.com/blog/nextjs-cache-on-vercel
Published: 2026-08-29. Updated: 2026-09-24.
On Vercel I start with the cache I can name, not a speed score.
The fetch. The tag. What busts it after a write. If I cannot say those three, I do not touch a CDN checkbox.
I already wrote the App Router I keep in `app/` and the API routes I trust. This post is the cache I set on that tree.
The offer page is Hire a Next.js developer. This is the practice, not a deploy brochure.
### What I set on fetch first
I open the fetch that feeds the page. I do not open the Vercel dashboard first.
A public list gets a window and a tag:
```
await fetch(url, {
next: {
revalidate: 3600,
tags: ["posts"],
},
});
```
revalidate is the ISR-ish window. After an hour the next request can rebuild. That is fine for a marketing page that changes once a day.
tags is the name I can bust. Without a tag, a write has nothing to poke. The page waits for the window, or for a redeploy.
I do not leave a default fetch with no window and no tag and call it “static.” On Vercel that fetch lives in the Data Cache until something evicts it. I want the eviction to be a function I wrote, not a hope.
If the page also has export const revalidate = 3600, I still put the tag on the fetch. The segment window and the fetch tag are not the same knob. I name both when both exist.
### Tags I can bust after a write
A write that does not name a tag is how an edit sits invisible.
The write lives in a Server Action when the form is ours, or in route.ts when the caller is a webhook. I already wrote which of those I trust. The cache rule is the same: after the row is saved, I call revalidateTag with the tag the list page used.
```
revalidateTag("posts");
```
If the list is tagged posts and the write busts post-123, the detail can update and the index stays stale. I bust every tag that page used. Sometimes that is two tags. I write them down before I ship the action.
When the Full Route Cache still serves old HTML after the data tag is gone, I add revalidatePath for that URL. The fetch cache and the route HTML are two layers on Vercel. A tag on the fetch does not always throw the HTML away.
I do not “purge everything” from the dashboard to hide a missing tag. That is a restart, not a cache design.
### When I use no-store
A fetch that reads a session cookie is cache: "no-store". Or the page uses cookies() and I still mark that fetch. Auth and cache stay in the same sentence.
A dashboard. An account header. A price that depends on who is signed in. Those are not ISR. I do not give them a 60 second window so the first user of the minute owns the page for the next.
no-store is for the request that must see this user, this write, this second. I use it on purpose. I do not sprinkle it on every public fetch because a page felt stale once.
A webhook POST is never cached. I said that in the API post. Same rule here.
### What still surprises me on Vercel
Stale HTML. I busted the data tag. The list JSON is new. The document is not. Vercel still has a route payload. I add revalidatePath or I tag the render in a way the path can see. Then I load the URL in a private window, not the tab I have been refreshing.
Preview vs prod. The preview URL is a different cache. Green on a preview deploy does not mean production is fresh. I check the production host after the write. I have burned time “fixing” a cache that was only wrong on my preview.
One tag missing. The write busts post-id. The index fetch is tagged posts. One of them updates. The other does not. I treat that as a missed name, not a Vercel outage.
Those three are the ones I still walk on a stale ticket. I do not start with “the CDN is broken.”
### What I skip
export const dynamic = "force-dynamic" on the root layout so cache bugs disappear. That turns the whole app into a request. You paid for a cache and then opted out of it for every URL. I use force-dynamic on the segment that must be dynamic, not on app/layout.tsx.
Hoping ISR without a write path. A 60 second window is not a publish button. If an editor saves a post, I want revalidateTag in that save. If I cannot name the write, I am not done.
A dashboard “purge cache” as the release step. If the only way to see an edit is a purge, the tag is missing.
### What I will take
I take a Next.js app on Vercel whose cache I can walk after a write. Show me the fetch, the tag, and the action that busts it. I will also take the messy case: a page that stays stale, a cookie fetch someone cached, a preview that lied about prod.
I will not take a speed-score project with force-dynamic on the whole tree and no owner for what happens after save.
If you want this owned on your product, that is the work on Hire a Next.js developer. Send the repo or the ticket.
---
## Headless WordPress with Next.js: how I wire the front
URL: https://madebyaris.com/blog/headless-wordpress-with-nextjs
Published: 2026-08-29. Updated: 2026-09-24.
I use WordPress as the CMS. Next.js is the site. That is the split.
The visitor hits Next.js. WordPress stores the post. I do not treat WP as the public page.
I already wrote when headless WordPress is worth it. That post is the why. This one is the practice: how I wire a headless WordPress Next.js front in App Router.
The hire doors are headless WordPress development and Hire a Next.js developer. This is the wiring, not a sales page.
### WP stays the CMS
WordPress holds posts, drafts, media, and the editor the client already knows. That is the job. I do not ask it to paint the public HTML.
A theme is not the site. A page builder is not the site. If a plugin is “the front,” I am not doing headless. I am running two sites and hoping they agree.
On madebyaris.com I write in wp.madebyaris.com. Status, slug, featured image, Gutenberg blocks. The public URL is a Next.js route. WP never sees that request.
### Next.js owns the request
App Router. A folder is a URL. page.tsx is a Server Component. It fetches. It tags the result. The visitor never waits on a PHP theme.
I already wrote the App Router I keep in `app/`. The headless case does not invent a new tree. Same layout, same small client boundary, same cache I can walk after a write.
If the request lands on WordPress and Next.js “pretty-prints” it later, that is not the split. Next.js owns the request from the first byte.
### How I fetch
REST. GET /wp-json/wp/v2/posts?slug=.... I ask for the fields I use: title, slug, content, excerpt, featured image, status. I do not pull the whole kitchen.
I fetch in the Server Component. I pass next: { tags: ['posts', 'post:' + slug] }. Public list can cache. A cookie or a draft cannot.
I do not open a GraphQL layer unless the product already has one I can name. A mystery GraphQL stack on top of REST I already trust is a second contract I have to debug at 1am.
Preview uses a secret. The public list does not. If I mix those two fetches, a draft leaks or a public page goes no-store for no reason.
### Draft and preview
Draft stays in WordPress. I do not flip a post to publish so I can “see it.”
Preview is a Next.js route. It reads the draft with an application password or a preview nonce. no-store. If I cache a draft, the next editor sees yesterday’s sentence.
The public slug route 404s a draft. That is the point. Status is the gate. The front does not invent a second status field.
### What I revalidate after a publish
I name the tags before I write the hook.
posts for the blog index. post:{slug} for the single URL. home only if the homepage lists posts.
A publish hook hits a Next.js route. It checks a secret. It calls revalidateTag or revalidatePath. Then the next visitor gets the new HTML.
If I cannot name the tag, the edit sits invisible until someone redeploys. I have already sat in that chair. I will not ship it again.
I do not bust the whole site because one post changed. That is how you turn a publish into a stampede.
### What I skip
Rewriting when headless is worth it. That page already owns the why.
Treating WordPress as the site and Next.js as a pretty cache.
A GraphQL schema I cannot walk in one sitting.
Caching a draft so preview “feels fast.”
A weekend “headless rewrite” with no owner for the front. Same failure as a Pages-to-App-Router big bang.
### What I will take
I will take a WordPress site that needs a Next.js front, or a Next.js front that still treats WP as the HTML. Fetch, draft, preview, a tag I can bust after publish. I will not take a rewrite that leaves two publics live and hopes they stay in sync.
If you want that owned, that is headless WordPress development or Hire a Next.js developer. Send the CMS URL and the front repo.
---
## Migrating a Pages app to App Router without drama
URL: https://madebyaris.com/blog/migrating-a-pages-app-to-app-router
Published: 2026-08-29. Updated: 2026-09-24.
I migrate a Next.js Pages app to App Router one URL at a time. I copy the data rules, keep a rollback, and I do not rewrite the whole tree in a weekend.
That is the migration. Not a big-bang folder rename.
I already wrote the App Router I keep in `app/`, when I still touch Pages, and the API routes I trust. This post is the move itself: how a Pages app becomes App Router without drama.
The offer page is Hire a Next.js developer. This is the practice, not a rewrite sales deck.
### Start with one URL
I pick one route. Not the home page first unless it is the simplest. Not “the dashboard” as a tree of twenty files. One URL I can name, ship, and roll back.
I write down three things before I touch files: where the session is read, what the page fetches, and what happens after a write. If I cannot say those three, I am not migrating that URL yet.
I leave every other Pages route alone. Mixed trees are fine when each URL has one owner. Drama starts when /account is still Pages and /account/settings is App Router with a different session story.
### Map the old calls, do not rename files
getServerSideProps does not become a Server Component by renaming the file. Cookies, cache, and the client boundary have to be decided again.
getServerSideProps. The request is the cache. In App Router I use a Server Component that reads the cookie and fetches with no-store or force-dynamic. If I leave a cookie fetch cacheable, two users will share a page. I already wrote that bug once. I will not ship it again.
getStaticProps plus revalidate. This one maps cleanly. A Server Component with a revalidate window or a tag is the replacement. I still name what busts it after a write. A static page with no tag is how a CMS edit sits invisible until someone redeploys.
getStaticPaths. generateStaticParams. Same job, different file. I generate the params I care about and I decide what happens for a path I did not list.
pages/api. A route.ts for external callers, or a Server Action when the write starts in our UI. I do not keep a new pages/api folder next to a working app/ tree for the same product surface.
_app and _document. app/layout.tsx and metadata. I do not paste _app into a client root layout so the old providers “just work.” Providers that need the browser stay in a small client shell. The layout stays a Server Component when it can.
### Keep a rollback before you cut over
I do not delete the Pages file on the first deploy of the App Router version. I prove the new URL. Then I remove the old one.
Before cutover I check four things:
Session is the same on both trees. Same cookie name, same auth helper, same “who is this” answer.
Cache tags are named. If the write path cannot say which tag to revalidate, the list page will stay stale.
The client boundary is small. A 'use client' on the whole page so hooks keep working is how you lose the reason you moved.
Rollback is one deploy. If the new route is wrong, I can put the Pages file back without a git archaeology session.
If any of those four is missing, I am not cutting over. I am still migrating.
### What I migrate first
Marketing pages with clear data. A blog index. A public product page that already had getStaticProps. Those teach the team the new file shapes without putting checkout at risk.
Then account pages that read a session. Those force the auth and cache sentence into the open.
Checkout, webhooks, and anything with money or signatures wait until the boring routes are boring. I already covered which API handlers I trust. The migration does not invent a new rule there.
### What I skip
A weekend “finish the migration” plan with no owner per URL.
Deleting pages/ while half the dashboard still imports from it.
Flipping the root layout to 'use client' so Pages habits fit.
Treating a renamed folder as a finished Next.js migration. The data rules are the migration.
Starting a brand new product in Pages so the old contractors feel at home. New work starts in app/.
### What I will take
I take the messy case: a Pages app with _app, a pile of getServerSideProps, a few pages/api webhooks, and a product that cannot go dark for a week. I move one URL, prove it, then the next. I will also take a clean app/ tree on a new product. I will not take a rewrite that ships half a checkout and hopes for the best.
If you want this owned on your product, that is the work on Hire a Next.js developer. Send the repo or the ticket.
Next in this series is what a Next.js developer should own on your product.
---
## Next.js App Router API: route.ts vs Server Actions
URL: https://madebyaris.com/blog/nextjs-app-router-api
Published: 2026-08-28. Updated: 2026-10-19.
A Next.js App Router API route earns a file when I can name the job. Webhook or cron goes in route.ts. Our own form is a Server Action. I do not open a new pages/api file on an app/ tree.
That is the whole set. Not a second Express app hiding in Next.
I already wrote the App Router I keep in app/ and when I still touch Pages. This post is the API question: which handlers I ship, which ones I refuse, and one route.ts example I will leave in a repo.
If you want this owned on a product, that is Hire a Next.js developer.
### What a Next.js App Router API route is
In App Router, an API route is a Route Handler. The file is route.ts under a segment, usually app/api/.../route.ts. You export GET, POST, PUT, PATCH, or DELETE. The function gets the request. It returns a Response.
That is it. No _app. No getServerSideProps. No leftover pages/api handler unless the old tree is still the owner.
I do not treat route.ts as a place to dump every write. If the browser form is ours, a Server Action is the shorter path: it runs on the server, it can revalidate a tag, and I do not have to invent a JSON contract for myself.
A Next.js App Router API route earns its file when something outside our form needs HTTP: a webhook, a cron ping, a mobile client, a tool that posts a signature.
People still search “nextjs api routes” and expect the old Pages file. The App Router answer is the Route Handler. Same HTTP job. Different file. Different defaults for cache.
### What I open
I pick the file from the job, not from habit.
Route handler (route.ts). External POST. Cron. A signed webhook. A GET that another service will call. The caller is not our React form.
Server Action. The write starts in our UI. Create, update, delete. The action checks the session, does the write, revalidates the tag. If I cannot name the tag, the action is not done.
pages/api. Only when the repo still lives in Pages and that route is already Pages. I still touch it to fix a broken webhook on an old tree. I do not add a new pages/api folder next to a working app/ tree. That is a second request path I have to explain on day two.
If I catch myself opening route.ts because I miss Express, I stop. The product is not a generic API. It is a Next app with a few HTTP edges.
### A route.ts example I will ship
Here is the shape I leave in a client repo for an external POST. Boring on purpose.
```
// app/api/webhooks/stripe/route.ts
import { NextResponse } from "next/server";
import { verifyStripeSignature } from "@/lib/stripe-webhook";
import { recordStripeEvent } from "@/lib/billing/events";
export const runtime = "nodejs";
export async function POST(request: Request) {
const rawBody = await request.text();
const signature = request.headers.get("stripe-signature");
if (!signature) {
return NextResponse.json({ error: "missing_signature" }, { status: 401 });
}
let event;
try {
event = verifyStripeSignature(rawBody, signature);
} catch {
return NextResponse.json({ error: "bad_signature" }, { status: 401 });
}
await recordStripeEvent(event);
return NextResponse.json({ ok: true }, { status: 200 });
}
```
What that example is doing:
- Read the raw body when the signer needs bytes, not a pre-parsed object.
- Fail closed on a missing or bad signature. Never return 200 to “stop retries” on a bad signature.
- One write. One job. Email, fan-out, and slow side effects wait for after() once the 200 is safe.
- Stay on Node when the crypto helper is not edge-safe. I do not flip runtime = 'edge' because a template did.
Status codes stay boring: 400 bad input, 401 or 403 auth, 404 missing, 409 conflict, 500 I log and I do not leak.
If the write is ours and a list page reads it, I revalidate the tag that page uses. A webhook that only writes a row and never busts the cache is how a dashboard stays stale until someone hard-refreshes.
### Auth and cache in the same sentence
This is the bug I still inherit. A GET handler reads a session cookie, Next caches it, two users see the same account.
Public GET can cache. A revalidate window or a tag is fine if the data is public and I can name what busts it.
Webhook POST is never cached. I do not add a cache header to look fast.
A route that reads a cookie is dynamic. force-dynamic or no-store. Auth and cache have to be in the same sentence. If I cannot say which, I do not ship the handler.
Our own form write stays a Server Action plus a tag. I do not wrap that write in a route.ts so I can “keep the API consistent.” Consistent with what. The form is the caller.
### What I skip
A new pages/api file on an App Router app.
A route.ts for a form that already lives in the same repo. That is a Server Action with extra JSON.
Caching a cookie GET and calling it a performance win.
A handler that returns 200 on a bad signature so the vendor “stops retrying.” That hides a bug you will pay for later.
Business logic in middleware. Middleware stays a redirect, a header, a rewrite. The write stays in the handler or the action.
Turning every Server Action into a public REST surface “for consistency” when there is no outside caller.
### What I will take
I take the messy case: a webhook that has to verify a signature, a cron that must not run twice, a cookie GET someone cached by accident, an old pages/api that still owns the request. I will also take a clean app/api tree on a new product. I will not take a rewrite that turns every form into a REST surface for no caller.
If you want this owned on your product, that is the work on Hire a Next.js developer. Send the repo or the ticket.
Next in this series: migrating a Pages app to App Router without drama.
---
## Next.js App Router vs Pages: when I still touch Pages
URL: https://madebyaris.com/blog/nextjs-app-router-vs-pages
Published: 2026-08-27. Updated: 2026-09-24.
I start new Next.js work in App Router. I still touch Pages on old repos, on mixed trees, and anywhere getServerSideProps still owns the request.
That is the comparison. Not a feature matrix.
In my previous guide on the App Router I actually keep in `app/`. This post is the other question: when pages/ is still on the disk, and what I do not rewrite in a weekend.
The offer page is Hire a Next.js developer. This is the practice, not a migration sales deck.
### New product: I do not open pages/
A 2026 product starts in app/. Layout, page, a small client boundary, a cache I can walk after a write. I wrote that set yesterday. I do not add a pages/ folder so the repo looks familiar.
Pages still exists in Next.js. That is not a reason to start there. _app, getServerSideProps, and pages/api are the old request path. On a new app they become a second tree I have to explain on day two.
If the ticket is a new product, the router is App Router. If someone wants Pages because the last contractor used it, I say no and I keep the reason short.
### Old repo: pages/ is still the tree
I inherit apps that live in pages/. _app.js, index.js, pages/api, a pile of getServerSideProps. The product works. Users are on it.
I do not rewrite that tree because a post said App Router is the only router. I open the data function first. I write down where the session is read, what the page fetches, and what happens after a write. If I cannot say those three things, I am not ready to move the route.
I still touch Pages to ship a fix: a broken query, a header, a form that posts to the wrong API. The fix stays in Pages if the route is Pages. Mixing one App Router file into a Pages-only tree without a plan is how you get two auth stories.
### Mixed repo: both folders, one URL at a time
A lot of client repos already have app/ and pages/ next to each other. New marketing pages landed in App Router. The dashboard is still getServerSideProps.
That is fine if each URL has one owner. It is not fine if /account is Pages and /account/settings is App Router and they do not share the session the same way.
When I migrate, I take one URL. I copy the data rules, not the file names. getServerSideProps does not become a Server Component by renaming the file. Cookies, cache, and the client boundary have to be decided again. I ship that URL. I leave the next one until this one is boring.
I do not pick a weekend and “finish the migration.” That is how you get a half-moved checkout and a rollback you cannot explain.
### What I still meet in Pages
getServerSideProps: the request is the cache. I do not pretend fetch with a tag is the same thing. If the page must see the cookie on every hit, I keep it that way until the App Router version says so in the fetch.
getStaticProps plus revalidate: this one maps. A Server Component with a revalidate window or a tag is the replacement. I still have to name what busts it after a write.
_app and _document: layout and the document shell. In App Router that is app/layout.tsx and a small metadata file. I do not paste _app into a client layout.
pages/api: route handlers in App Router, or a Server Action when the work is ours. I do not open a new pages/api file on an app that already has app/.
### What I skip
Starting a 2026 product in Pages.
Flipping a root layout to 'use client' so the Pages habits fit.
A rewrite with no rollback URL. If I cannot keep the old route live while the new one is proven, I am not migrating yet.
Treating “App Router” on a job post as the architecture. The folder on disk is the architecture.
### What I will take
I take the messy case: old pages/, a mixed tree, a route that still needs getServerSideProps until we can walk the cache. I will also take a new app/ tree. I will not take a rewrite of the whole site with no owner for each URL.
If you want this owned on your product, that is the work on Hire a Next.js developer. Send the repo or the ticket.
---
## Next.js App Router in Practice: Production Patterns
URL: https://madebyaris.com/blog/nextjs-app-router-in-practice
Published: 2026-08-26. Updated: 2026-09-24.
I use Next.js App Router as a route tree I can explain, not a React SPA wearing a Next badge.
Server Components stay the default. A page gets a layout, a page, and the files that catch loading and errors. A client boundary appears only when a click or a form needs the browser. If I cannot walk a cache miss after a write, the route is not done.
In my previous guide on what I open when someone asks me to hire a Next.js developer. This post is the other side: the App Router I actually keep in app/.
The offer page is Hire a Next.js developer. This is the practice, not the docs tour.
### The route tree I keep
I start in app/. Not in a components/ dump.
Each folder is a URL segment. layout.tsx wraps the children. page.tsx is the segment. loading.tsx, error.tsx, and not-found.tsx sit next to them when that segment can stall, throw, or miss.
I do not invent extra folders to look tidy. If a segment does not need its own loading state, I do not add the file. Empty ceremony is how App Router turns into a maze.
Route groups, the folders with parentheses, stay for shared chrome that should not change the URL. I use them when marketing and app chrome need different shells. I do not nest three groups because a tutorial did.
### Server first, then a client boundary
A new file is a Server Component unless I write 'use client' at the top.
That is the whole rule. Fetch, cookies, headers, and the first render stay on the server. The button that opens a dialog, the input that needs local state, the chart that must live in the browser: those go in a small client file. I import that file into the server page. I do not flip layout.tsx to 'use client' so I can use useState everywhere.
I have inherited apps where every page is a client tree. They work until you need a cached list, a session cookie, or a form that should not ship 200kb of hooks. Undoing that is slower than writing the boundary the first time.
If I cannot point at the file that crosses into the browser, I do not ship the route.
### Data I can explain
I pick one list page and I write down three things: where the data is fetched, how long it can stay, and what busts it after a write.
fetch in a Server Component, a revalidate window or a tag, and a path or tag I can call after the write. That is enough for most product lists.
I do not cache a page that reads a session cookie and then act surprised when two users see the same dashboard. Auth and cache have to be in the same sentence. If the page is private, I say so in the fetch, or I do not cache it.
Route handlers stay for webhooks, cron, and the cases where a form cannot be a Server Action. I do not open a new route.ts because I miss Express.
### Metadata and the bits I still touch
Titles come from the route metadata or generateMetadata. I set them on the page that owns the URL. I do not stack a layout title and a page title and hope they do not double. I already fixed that class of bug on this site.
Forms that create or update a record use a Server Action when the work is ours. The action revalidates the tag. The list page updates. If I cannot say which tag, the form is not finished.
middleware stays thin: auth redirect, a header, a rewrite. Business logic does not live there.
### What I skip
A root layout marked 'use client'. That is a SPA with extra steps.
A Pages-only habit on a new app. Pages still exists. I still touch it on old repos. I do not start a 2026 product there.
A cache I cannot walk. If the only answer is “Next handles it,” the page will go stale on a launch day and nobody will know which file to open.
I also skip the version argument. App Router in production is the practice. The badge on a job post is not.
### What I will take
I take scoped App Router work: routes, auth, cache, metadata, the boring parts that break. If you need a bench next week, I will say so.
If you want this owned on your product, that is the work on Hire a Next.js developer. Send the repo or the ticket.
Next in this series is App Router vs Pages: when I still touch Pages.
---
## Hire a Next.js developer: what good looks like in 2026
URL: https://madebyaris.com/blog/hire-a-next-js-developer-what-good-looks-like-in-2026
Published: 2026-08-25. Updated: 2026-09-24.
When someone asks me to hire a Next.js developer, I do not start with years of React.
I ask for a repo they shipped. I want App Router routes they own, a page that went stale and how they fixed it, and a pull request they can explain file by file. If they cannot show those, the resume does not matter.
Founders still write “need a React person who knows Next.” That used to be enough. In 2026 it is how you hire someone who wraps the whole app in 'use client' and calls it done.
The offer page is Hire a Next.js developer. This post is the screen I run before I say yes, or before I tell you to keep looking.
### What I open first
I clone or I get a walkthrough. Then I look at four places. Not the README.
app/. I want routes they actually shipped. A Server Component that fetches, a small client island for the part that needs a click. If layout.tsx is 'use client' and every page is a client tree, they are still writing a React SPA inside Next. I have inherited that. It is slow to undo.
The cache. I pick one list page and ask why it is stale after a write. fetch cache, revalidate, a tag, a cookie that opted the page out. I do not need the perfect Next docs answer. I need them to remember a real miss. If they shrug, they have not been on call for that app.
Auth on a cached page. Session cookie, expired token, a dashboard that still shows yesterday’s user. This is where “I know Next” dies. If they cannot say where the session is read and what happens when it expires, they have not owned login.
The last PR. I scroll the files they did not need. Extra util. Second type file. A folder that does not exist elsewhere in the repo. I wrote a PR review checklist for AI-generated code because this is the same mess whether a person or a model wrote it. If they cannot explain the leftovers, they will not survive your review either.
### What I skip
I have wasted calls on the same three things.
A resume that lists Next, React, TypeScript, and a version number. I already assumed that. Show the repo.
A Pages-only portfolio. Pages still exists. I still touch it on old apps. If that is the only Next they have shipped, they will need a month on App Router before they help you. Say that up front. Do not hire them for an app/ rewrite and hope.
A candidate who cannot walk a cache miss. They will guess in production. You will find out on a launch day.
I do not screen on “Next.js 13+.” That is a job-post leftover. App Router in production is the bar. The version on the badge is not.
### Questions I ask on the call
Same four, every time. I want the repo open, not slides.
- Show me one App Router route you own. What stayed a Server Component, and what had to be a client component?
- Walk a cache miss. What did you change, and how did you know it worked?
- Where is auth read, and what happens when the session expires on a cached page?
- Open your last PR. Which files could you have left out?
If they need a deck to answer those, they are not the hire. If they say “I would have to check,” that is fine once. Twice means they did not own it.
### What I will take, and what I will not
I am one person. I take scoped Next.js work: App Router, auth, cache, the boring parts that break. If you need a bench of five next week, I will tell you I am the wrong call.
If you need someone who already ships this way, that is the work on Hire a Next.js developer. Send the repo, or the ticket. I will tell you if it is a fit.
Next in this series is App Router in practice: what I actually use, not the docs tour.
---
## RankMySEO SaaS vs Open Source: Which to Pick?
URL: https://madebyaris.com/blog/rankmyseo-saas-vs-open-source
Published: 2026-08-24. Updated: 2026-10-24.
People keep asking me which RankMySEO they should use. Fair question. There are two products with one family name, and I will not pretend they are the same thing.
I maintain both the public toolkit and the private hosted SaaS because different teams need different ownership models.
### Two products, one problem
The problem is simple: ranks without history are gossip. You need a loop that stores where you stood yesterday, not only a live peek that disappears when the tab closes.
How you run that loop is the fork.
### The open-source toolkit
The public repo is https://github.com/madebyaris/rankmyseo. That is the OSS path: packages you install, adapters you wire, audits and agent tools you keep behind approval gates.
Choose OSS when:
- You want the loop inside your monorepo
- Your team can run and extend the stack
- You need framework adapters and custom agent surfaces
- You care about reading and changing the code in the open
Status stays honest: milestones are shipped, offline paths are verified, live connectors need your own setup. Docs live in the wiki on that same public repo.
If RankMySEO for you means “ship packages into our product,” start there.
### The private SaaS
The hosted product source is https://github.com/madebyaris/rankmyseo-saas. That repo is private. I list it so the split is clear. You should not expect to browse SaaS source the way you browse the OSS tree.
RankMySEO SaaS is a clickable hosted MVP: persistent project history, background rank checks, daily SERP for project keywords. Overview, Keywords, Competitors, and Insights work. Proven on the diurusin.id demo. Not a chargeable public product yet. Stripe is not MVP.
Choose SaaS when:
- You want managed tracking without operating the tracking stack
- You need daily SERP history stored for you
- Marketing or SEO leads need a board, not a package install
- You are fine with a private hosted product next to the public toolkit
### The Competitors tab and the keyword matrix
Competitors is where the SaaS earns its keep for comparison work. You are not only watching your own keywords. You are looking at how your project sits next to others on the same queries.
The keyword matrix is the practical view: your keywords across competitor domains, so gaps and overlaps are visible without exporting five CSVs into a spreadsheet ritual.
This is not a claim that you will beat every rival next week. It is a claim that the matrix is real UI on a working MVP, backed by stored snapshots, not a mockup slide.
Optional context from Overview helps when you jump back to project health after a competitor pass:
I keep the same product rule as the rest of RankMySEO SaaS: the UI shows history we store for your project. Rank checks run in the background. You read the board; you do not babysit the crawl path.
### Ownership, not plumbing
OSS is the opposite ownership story: you host and extend the pieces you choose.
SaaS is the managed board: projects, keywords, competitors, and history you can reopen without operating the tracking stack yourself.
### When to use which
Use the open-source toolkit if you are building SEO or agent loops into a product, you want Apache-2.0 code in the open, and your engineers will own deploy and extension.
Use RankMySEO SaaS if you want a hosted board for projects, keywords, competitors, and insights, with daily SERP history you do not operate yourself.
Use both if your eng team embeds the toolkit while growth watches the SaaS matrix. That is a normal split, not a contradiction.
Do not use either as a substitute for content quality. A matrix that shows you losing on a query still needs a better page. Tools measure. You ship the fix.
### What I will not claim
I will not invent ranks, traffic charts, or a public launch URL beyond what is real. I will not say the SaaS source is publicly browsable. I will not say Stripe billing is ready. I will not invent a beta signup form URL.
What is real: clickable MVP, project history, background rank checks, daily SERP for project keywords, Overview / Keywords / Competitors / Insights working on the diurusin.id demo path, open beta next week.
### Open beta next week
Open beta next week. Week of 2026-08-31, early September 2026.
Watch the site. For early access, reach out via https://madebyaris.com/services. Mentoring if you want a human in the loop. Build path if you need a Next.js product around this stack: https://madebyaris.com/services/nextjs-development.
If you only want the toolkit today, skip the wait and use the public GitHub: https://github.com/madebyaris/rankmyseo.
### Closing
RankMySEO is a family name for two honest paths. OSS for self-hosted teams who live in the repo. SaaS for managed tracking and a competitor keyword matrix you can actually click.
If you want someone to set up tracking and act on the data, see my SEO services.
Pick the ownership model that matches your team. Open beta next week for the hosted side. The public toolkit is already there for the code side.
Own the history. Then decide who you are competing with, and what you will ship next.
---
## Introducing RankMySEO SaaS: rank history you actually own
URL: https://madebyaris.com/blog/introducing-rankmyseo-saas
Published: 2026-08-24. Updated: 2026-10-24.
I already open-sourced RankMySEO as a toolkit you can drop into your own stack. That path is still the right one if you want packages, adapters, and full control in your repo.
But a lot of people asked a simpler question: can I just track ranks somewhere hosted, keep the history with the project, and not babysit crawlers on a Friday night?
That is why RankMySEO SaaS exists. It is a private hosted product next to the public OSS toolkit. Same family. Different job.
I build RankMySEO because rank talk without history is just storytelling.
### Why a hosted product next to the OSS toolkit
The open-source RankMySEO toolkit is for teams who want to install, adapt, and own the loop in code. Packages, adapters, audits, agent tools with approval gates. If that is your world, stay there.
RankMySEO SaaS is for the other case: you want a clickable product that stores SERP history for your projects, runs rank checks in the background, and shows Overview and Keywords without you operating the tracking stack. The SaaS source lives at https://github.com/madebyaris/rankmyseo-saas. That repo is private. I mention it so the split is honest: public toolkit vs private hosted product. Do not expect to browse the SaaS source on GitHub like the OSS tree.
Honest product state today: this is a clickable hosted MVP. Persistent project history. Background rank checks. Daily SERP for project keywords. Overview, Keywords, Competitors, and Insights are working. I have proven that path on the diurusin.id demo. It is not a chargeable public product yet. Stripe is not in the MVP.
### What you see on Overview
Overview is the home screen for a project. You land, you see the project context, and you get a read on how keywords are doing without jumping into five tabs first.
The point is not a vanity dashboard. The point is history you own. When ranks move, the movement lives in our database, not in a screenshot folder on someone’s laptop.
Check ranks queues the work in the background. The board stays responsive. You come back to results in your project history, not a spinner that owns the page.
If you have used tools that freeze the page while a crawl runs, you already know why that matters. Overview is for reading the state. The queue is for doing the work.
### Keywords: daily SERP and history you can trust
Keywords is where the focus keyword work lives day to day. You attach keywords to a project. The system runs daily SERP for those project keywords. Snapshots stay with the project so you can look back instead of guessing.
I care about this more than fancy charts. If your rank history evaporates when a tool changes pricing or an account dies, you do not own the loop. RankMySEO SaaS keeps that history with the project. The UI reads what we stored, not a one-off live peek.
You still need judgment. A keyword at position 8 that never converts is not a win because the chart went green. The SaaS gives you the time series. You decide what to ship next.
### Built so history sticks
The product rule is simple: the board you open should show ranks you can trust tomorrow, not a live peek that vanishes when the tab closes.
When you check ranks, the work runs in the background. The UI stays fast. Results land in your project history, so Overview and Keywords stay useful the next day.
You do not operate crawl infrastructure. You open a project and read what changed.
If you want the self-hosted toolkit instead, the OSS path is still https://github.com/madebyaris/rankmyseo. Same family name. Different job.
### What is in and what is not
In for the MVP you can click today:
- Project Overview that reflects real stored data
- Keywords with daily SERP and history
- Competitors and Insights (more on the matrix in a follow-up post)
- Background rank checks that do not freeze the UI
- Persistent project history you can reopen later
Not in the MVP:
- Public paid billing (Stripe is not MVP)
- Pretending this is a finished chargeable launch
- Invented traffic numbers or fake rank screenshots for marketing
I would rather ship an honest beta than a landing page that lies.
### Open beta next week
Open beta next week. That is the week of 2026-08-31, early September 2026.
I am not inventing a beta signup URL here. Watch the site, and if you want early access, reach out through https://madebyaris.com/services. Mentoring fits if you want a human on the loop. If you need a Next.js product built around SEO tracking, the Build path is https://madebyaris.com/services/nextjs-development.
If you prefer to stay in code and self-host the toolkit, start with the public GitHub and skip the wait.
### Who this is for
Use RankMySEO SaaS if you want managed tracking, daily SERP history you do not have to operate yourself, and a UI that already works for Overview and Keywords.
Use the OSS toolkit if you want packages in your monorepo, custom adapters, and full control of how agents and audits run.
Plenty of teams will use both: toolkit in the product codebase, SaaS for the marketing or SEO lead who just needs the board.
### Closing
RankMySEO SaaS is the hosted answer to where do my ranks live over time. The OSS toolkit remains the answer to how do I wire this into my stack.
For rank tracking plus fixes made in the code, see SEO audits and monthly SEO.
Overview and Keywords are real. Project history is real. Background rank checks are real. Open beta next week. Reach out via services if you want in early, or watch the site as we open the door.
I built this because I got tired of SEO conversations that never had yesterday’s position. Own the history. Then decide what to ship.
---
## SEO for AI and LLMs vs GEO: what actually changes
URL: https://madebyaris.com/blog/seo-for-ai-vs-geo
Published: 2026-08-24. Updated: 2026-09-24.
People keep asking me: “Do we still need SEO, or is it all GEO now?”
Wrong question. SEO for AI is not a rebrand of classic SEO, and it is not the same as generative engine optimization. They share a site, not a scoreboard.
I am building RankMySEO in the open because this topic got too loud and too vague.
### Classic SEO did not leave the building
Blue links still pay rent.
Google, Bing, and the long tail of search still send traffic when you have a clear query, a useful page, and a site that does not fight crawlers. Titles, meta, headings, internal links, Core Web Vitals, Search Console, backlinks that are not spam: that stack did not vanish because ChatGPT can summarize a blog post.
If your product page cannot rank for the boring commercial query, “AI SEO” will not rescue you. Classic SEO is still the system that puts a URL in a results list a human clicks.
When someone says geo vs seo like GEO replaced SEO, I push back. GEO sits on top of a site that already works. It does not replace crawlability, indexation, or a page that answers the question.
### What people mean by SEO for AI and LLMs
“SEO for AI” and “SEO for LLM” usually mean: make the site easy for machines to read, trust, and reuse, without assuming a blue link is the only win.
In practice I mean three layers:
Clarity. One page, one job. Plain headings. Claims that match the body. Dates and ownership that are not buried. Models and agents get confused the same way juniors do: vague titles, thin paragraphs, and three CTAs fighting for attention.
Structure. Schema where it earns its keep. Clean HTML. Consistent entity names. Sitemaps that are not fiction. Optional agent-facing surfaces like llms.txt or markdown negotiation so a tool can fetch a readable slice. Those are readiness aids. They are not magic ranking levers, and I will not pretend they are.
Measurable loops. Keyword and rank tracking still matter. Audits still matter. If you cannot see what moved, you are guessing. SEO for AI without a dashboard is a vibe.
So seo for ai is not “write for robots only.” It is classic craft plus machine-readable clarity, plus optional surfaces so agents can work without scraping your marketing spaghetti.
### What GEO is
GEO is generative engine optimization: get cited, quoted, or used inside generative answers.
The scoreboard is different. You care whether the model names you, links you, or paraphrases you in an answer box, not only whether position 3 on page one moved up. Brands, entities, clear sourcing, and pages that are easy to extract from help. Thin listicles that already lost classic SEO usually lose GEO too.
GEO does not mean abandon Search Console. It means you add another outcome: citation in AI answers. If your team only watches blue-link rank and ignores whether assistants mention you, you are half blind. If they only chase “get cited” and ignore crawl errors, they are cosplaying strategy.
### The real difference
Three jobs. Do not mash them into one KPI.
Classic SEO: rank and earn the click on a results list.
SEO for AI / LLMs: make the site clear and structured so machines (and humans) can use it, including optional agent surfaces.
GEO: get included in generative answers.
Same codebase. Different scoreboards. When a founder says “we need GEO,” I ask which number they will check next month. Rank for a query set? Citation screenshots? Both? If they cannot answer, they are buying a label, not a plan.
### What I tell teams to do this month
Skip the rebrand deck. Do the boring work.
- Fix crawl and index basics. No orphan pages, no soft 404 theater, no blocked CSS that breaks rendering.
- Rewrite the money pages so each one answers one query with a real outline. Use the focus phrase where it belongs: title, H1, early body. For this topic that means saying seo for ai when you mean that job, not stuffing every synonym into one paragraph.
- Add or clean schema that matches visible content. Do not invent FAQ markup for questions the page does not answer.
- Keep Search Console and a rank tracker honest. Pick a small keyword set. Watch it weekly.
- If you want agent readiness, add sitemap hygiene and, if it fits the stack, something like llms.txt or a markdown view. Treat it as documentation for tools, not a promised SERP boost.
- For GEO, publish primary sources: clear author, clear product facts, pages worth citing. Thin affiliate roundups do not become citation magnets because you renamed the channel.
If you need a human to sit on the repo and install that loop, that is mentoring. If you need the product and content system built, that is the Build path.
### What we are building with RankMySEO
I got tired of SEO talk that never touched the codebase. So we open-sourced RankMySEO under Apache-2.0.
It is a framework-agnostic JS/TS toolkit under the npm org @rankmyseo. Path is simple: npm i rankmyseo, then npx rankmyseo install.
You get keyword and rank tracking, audits, live scan, meta and schema helpers, dashboard widgets, an AI agent plus MCP that is approval-gated, and adapters for Hono, Express, Next, and Nitro.
Optional pieces cover sitemap, llms.txt, and markdown negotiation as agent-readiness. The README is honest: those are not evidenced SEO ranking levers. They are for tools that need a clean read.
Status today: milestones M0 through M5 are shipped. Offline paths are verified with a fixture datasource and a mock LLM. Live Google Search Console, PageSpeed Insights, and real LLM calls need your keys. Docs live in the wiki.
Next to the OSS toolkit, a hosted SaaS scaffold is in progress. No public SaaS URL to announce here, and no fake launch date. If you want the toolkit in your repo now, use the GitHub and npm path above.
That is how I connect the theory to shipping: track ranks, audit the site, keep agent tools behind approval, and stay honest about what moves rankings versus what helps machines read you.
### Bottom line
Classic SEO still ranks blue links. SEO for AI is clarity, structure, and optional agent surfaces. GEO is citation inside generative answers. Different scoreboards, one site.
Do the crawl and content work first. Measure ranks. Then decide if citation is a real KPI for your brand. Use tools that keep you honest, not decks that rename the same checklist.
If you want help wiring that into a real Next.js or AI product stack, start at services or the Next.js build path. And if you want the OSS loop in your repo, RankMySEO is there: install, audit, track, keep the agent gated.
---
## How teams should roll out Cursor in the first 30 days
URL: https://madebyaris.com/blog/how-teams-should-roll-out-cursor-in-the-first-30-days
Published: 2026-08-24. Updated: 2026-09-24.
Buying Cursor seats for everyone on Monday is not a rollout.
It is a license dump. By Friday you have three invented folder maps, no shared rules, and PRs nobody can explain. That is not cursor ai for developers. That is a tool drop with no fence.
When a team asks me to “just turn it on,” I slow them down. Two or three people, one repo, shared rules, then expand.
The production loop is How to use Cursor AI to ship faster without wrecking the codebase. The daily habits are in How to use Cursor AI effectively on a real repo. This post is the team version: a 30-day plan that does not torch the codebase.
### Why a big-bang seat dump fails
Cursor is not a plugin you sprinkle on a sprint. It writes code. If ten people write with no shared fence, you get ten architectures.
I still see the same three failures:
No fence. Nobody wrote project rules. Each person invents a folder, an error shape, a test command. Composer follows whoever typed last.
No review habit. People merge the summary. Extra files land. Helpers get duplicated. Tests stay skipped. I wrote the PR review checklist for AI-generated code because this is the first thing that breaks on a team.
Invented architecture. A new utils/ next to lib/. A second UI kit. A package nobody asked for. One developer can undo that. Ten developers do it in parallel.
If your first week is “everyone gets a seat,” you will spend month two cleaning up month one.
### The first 30 days, in one picture
Keep the first month small. Shared rules. One repo. Review the diffs. Then expand.
That is the whole plan. Seats come after the habit, not before.
### Week 1: two or three people, one repo
Pick people who already review PRs. Not the loudest. Not “everyone who asked.”
Install Cursor on that group only. Point them at one repo, the one you actually ship. Do not start on a toy app. Toy apps teach toy habits.
On day one, add project rules in git. Stack, folder map, do not create packages, error shape, test command. The long version is Project rules that stop Cursor from inventing bad architecture. Put the file in the repo so Chat and Composer both see it. A wiki page nobody opens is not a rule.
Split the tools. Chat plans. Composer (or Agent) ships a scoped diff. If you skip that split, people treat Composer like Chat with write access. I covered when I use each in Chat vs Composer in Cursor.
Week 1 success is boring: the small group can explain every file they merged. If they cannot, do not add seats.
### Week 2: review the diffs, share the rules
Week 2 is not “more people.” It is the review gate.
Run the PR checklist on every Composer diff: blast radius, no new top-level folders, types match siblings, tests that already existed, secrets or payments only if the ticket named them, no “while we are here.” If a box fails, the PR is not ready.
Put the rules file on the same PR habit as code. When someone finds a new pattern (“we do not add utils/“), it goes in the rules, not in Slack. Slack is a rumor. Git is the fence.
Pair on one real ticket. Sit together, plan in Chat, ship a small Composer diff, review it out loud. That hour teaches more than a lunch-and-learn.
If the first group is still merging summaries, you do not have a rollout. You have a mess with better autocomplete.
### Week 3 and 4: expand only after they can explain the diff
Add the next two or three people only when the first group can:
- Point at the rules file and say what it blocks.
- Review a Composer PR without rubber-stamping the summary.
- Split Chat (plan) and Composer (scoped write) without being asked.
Then copy the same loop: same repo, same rules, same checklist. Do not open a second repo “to experiment.” Experiments leak into prod.
By week 4 you want a short written loop the team owns: rules in git, Chat then Composer, checklist on the PR, revert extra files. If that loop is not written down, it will die the first busy week.
### What not to do
Three moves that look fast and cost you a month.
Everyone day one. Ten seats, ten invented maps. Start with two or three.
No fence. If the rules are not in the repo, Composer will invent a stack. Write them before the second person joins.
Merge the summary. “Looks good” on a Composer recap is not review. Read the diff. Cut the extra. Split the work if it is 30 files.
I would also skip: a company-wide enablement deck before anyone has merged a real PR, a second AI tool in the same sprint, and letting each person keep a private rules file. One fence. In git.
### A 30-day checklist you can paste
Week 1
- Two or three people, one shipping repo.
- Project rules committed.
- Chat vs Composer split agreed out loud.
Week 2
- PR checklist on every AI diff.
- Rules updated when you find a new “do not.”
- One paired ticket, reviewed together.
Week 3-4
- Add people only if the first group can explain diffs.
- Same repo, same rules, same checklist.
- Write the loop down. Keep it short.
That is cursor ai for developers as a team, not as a seat count.
### If the team is stuck
Most teams do not need a new model. They need the fence and the review habit installed on the real repo.
I coach that in Cursor mentoring. I sit with the team on the actual codebase, not a demo. If you need the product built instead of the habit installed, that is the Build path. Most teams do not. They need to stop dumping seats and start reviewing diffs.
Small group. Shared rules. One repo. Then expand.
---
## PR Review Checklist for AI-Generated Code
URL: https://madebyaris.com/blog/pr-review-checklist-for-ai-generated-code
Published: 2026-08-23. Updated: 2026-09-24.
Pull requests created with AI coding assistants (like Cursor, GitHub Copilot, or Claude) look remarkably clean at first glance. The formatting is tidy, the comments are polite, and the automated summary sounds completely confident.
That surface polish is precisely why AI-generated code is dangerous when reviewed casually. Unlike human juniors who leave telltale syntax errors or messy indentation when they are confused, language models generate syntactically perfect code that can be subtly wrong in architecture, security, or error handling.
Here is the practical review checklist I use on real production codebases to catch silent regressions, maintain code standards, and ensure AI code remains an asset rather than technical debt.
### Why AI Pull Requests Need a Different Review Posture
Human engineers usually make mistakes because they misunderstand syntax or miss a library feature. AI models make mistakes because they lack genuine architectural intent:
- They solve local problems by duplicating global code: If the model cannot easily find an existing date formatting helper or API client, it silently writes a new one in the current folder.
- They hallucinate non-existent parameters: The model may invoke a third-party library method with options that look plausible but are unsupported in your installed version.
- They gloss over failure paths: Happy paths are generated thoroughly, while network timeouts, database reconnections, and null checks are frequently skipped.
### The 5-Point Review Checklist
#### 1. Scope and Blast Radius
- Did the PR touch files outside the agreed feature boundary?
- Were existing configuration files (such as package.json, tsconfig.json, or lint configs) modified unnecessarily?
- Did any new packages or dependencies get added to the lockfile without team approval?
#### 2. Architecture and Code Reuse
- Does this PR duplicate logic, constants, or types that already exist elsewhere in the repository?
- Does the code follow your project’s established conventions (e.g., Server Components vs Client Components in Next.js, or repository patterns in backend services)?
- Are state boundaries and component responsibilities properly separated?
#### 3. Security and Data Validation
- Are all incoming user inputs, route parameters, and request payloads strictly validated with a schema (such as Zod)?
- Are authorization checks enforced on server actions and API routes, rather than relying solely on client-side UI visibility?
- Are sensitive tokens, API secrets, or internal error messages exposed to client bundles or browser logs?
#### 4. Error Handling and Edge Cases
- What happens when downstream APIs return a 4xx, 5xx, or network timeout? Are errors surfaced gracefully to the user?
- Are loading, empty, and partial states properly rendered in the UI?
- Were try/catch blocks added with proper logging, or are errors silently swallowed?
#### 5. Automated Tests and Verification
- Are unit and integration tests included for the new logic, testing both success and failure conditions?
- Do the tests actually assert business requirements, or did the AI write trivial tests that pass regardless of logic bugs?
- Does tsc --noEmit and the project linter pass cleanly without warnings?
### Copy-Pasteable PR Review Template for Teams
You can drop this markdown template directly into your team’s .github/pull_request_template.md to standardize reviews across your engineering team:
```
### AI-Assisted Code Verification Checklist
- [ ] **Boundary Check:** All modified files are strictly within the intended feature scope.
- [ ] **No Unvetted Deps:** No unapproved packages added to package.json / lockfile.
- [ ] **Deduplication:** Verified that existing helpers and types were reused rather than recreated.
- [ ] **Security & Auth:** Server-side input validation and auth checks are explicitly tested.
- [ ] **Error Handling:** Empty, loading, and failure states are tested and accounted for.
- [ ] **Real Tests:** Unit/integration tests verify business outcomes, not just mock tautologies.
- [ ] **Clean Lint & Types:** Typecheck and linters pass with zero warnings.
```
### Building Better Review Habits Across Your Team
AI tools can double an engineering team’s output, but only if your code review process adapts to catch architectural and subtle logic errors before they reach production.
If you want to train your engineering team on setting up Cursor project rules, review workflows, and PR standards, explore my Cursor mentoring and team coaching services.
---
## How to use Cursor AI to build an app without a mess
URL: https://madebyaris.com/blog/how-to-use-cursor-ai-to-build-an-app
Published: 2026-08-22. Updated: 2026-08-22.
People type “build me an app” into Cursor, go make coffee, and come back to a repo they cannot explain.
A new UI kit. Three extra packages. Zero tests. That is not how to use Cursor AI to build an app. That is a demo with extra steps.
I’m Aris Setiawan. Senior full-stack, first Cursor Ambassador in Indonesia. I ship client work in Cursor every week, including greenfield apps.
This is not “build Twitter in 20 minutes.” The production loop is How to use Cursor AI to ship faster without wrecking the codebase. If you just installed Cursor, start with the beginner tutorial. The messy-repo version is How to use Cursor AI effectively on a real repo. This post is the small-app version: one feature, your stack, a fence, then a loop.
### Why “build me an app” dumps a mess
Cursor is helpful. A wish with no map invents.
Four things I still see when someone pastes “build me a task app”:
Invented stack. You use Next.js App Router and pnpm. The model still drops a Pages Router leftover, an npm lockfile, or a Prisma schema you never asked for.
Extra packages. A toast library. A form library. A state library. You needed a list and a form. You got a starter kit.
No tests. The demo looks done. Nothing fails if the write path is wrong.
No fence. No project rules. No named folders. Composer (or Agent) picks architecture from vibes. That is the 30-file “hello world.”
“Build me an app” names a wish, not a pattern.
### Pick a tiny first slice
Do not ask for the product. Ask for one list and one write path.
A notes app is not “auth, tags, search, sharing, and a landing page.” It is: list notes, create a note, see it on the list. That is a Cursor Next.js slice I will actually review.
Name the stack you already use. Out loud. In the prompt. In the rules. Mine, on most of this work: Next.js App Router, TypeScript, pnpm, Tailwind. If that is not yours, write yours.
Three rules for the first slice:
- One user-visible behavior. List plus create.
- Paths you can name before you generate. app/notes, lib/notes, maybe components/ui.
- A test you can run. Empty list. Create one note. See it.
If you cannot name the folders, you are still in the wish. Stay in Chat until you can.
Scaffold the Next.js app yourself, then let Cursor fill the slice. You do not build an app with Cursor by asking for the product. You build the first ticket.
### Install the fence first
Before Composer writes a file, put the fence in.
The full version is Project rules that stop Cursor from inventing bad architecture. For a small app I still use the same half page: stack, folder map, do not create a new package or top-level folder, prefer lib/ over a new utils/, error shape, test command, no drive-by refactors.
I drop .cursor/rules in before the first Composer job. Empty rules plus “build me a notes app” is how you get packages/notes-v2 and a second button.
### The loop: Chat, Composer, review
Same split I use on client work: Chat vs Composer in Cursor.
Chat plans. “We need a notes list and a create form. Propose the smallest Next.js App Router change. Do not write files. Name the paths.”
Composer ships a scoped diff. Open those files. @ them. Name what is off-limits.
You review like a PR. Types, extra folders, a package you did not ask for, the test it skipped.
A loop I trust on a new app:
- Rules exist. Stack and folders are named.
- Chat names the files for this slice. Plan only.
- Open those files. Run Composer once, with a blast radius.
- Read every file it touched. If it opened a stranger, stop.
Composer without a plan is Chat with write access. That is how a notes list becomes auth, Prisma, and a dashboard you did not ask for.
### A prompt I would actually run
Generic Next.js App Router. First slice of a notes app, on top of the rules file.
Chat first:
Plan a notes list plus a create form in this Next.js App Router app. Stack is already Next.js App Router, TypeScript, pnpm, Tailwind. Do not write files. Name the paths under app/notes and lib/notes. Do not add auth, Prisma, or a new package. Propose one test for the create path.
Then Composer, after I open those files:
Build only the notes list and create form. Touch app/notes and lib/notes only. Reuse components/ui. Follow project rules. Do not create a new top-level folder or a new package. Match the error shape { error: string, code?: string }. Add a colocated *.test.ts for empty list and one successful create. Do not add auth, search, or tags.
That is how to use Cursor AI to build an app without a mess: one slice, named files, a fence. If Composer wants Prisma because “we will need it later,” I say no. Later is another ticket.
### What “done” looks like
“Done” is not a demo in the browser. I check this:
- pnpm dev runs. The list loads. I can create one note and see it.
- pnpm test runs. Empty list and one create are covered. I still click the happy path.
- No extra top-level folder. No extra package in package.json I did not ask for. No utils/ next to lib/.
- The diff is still PR-sized. A teammate can find the feature in app/notes.
If the repo looks like a starter-kit mashup, you got faster at making mess. That is the opposite of a Cursor AI app you can keep. Ship the slice. Auth last, when the write path is real.
### What I tell mentees
People ask how to use Cursor AI to build an app, then they paste the whole product into Composer and wonder why the repo is a mess.
One list. One write path. Your stack. Fence first. Chat to plan. Composer with named files. Review like you own the on-call.
I coach this in Cursor mentoring when someone has a greenfield dump they cannot explain. The fix is almost never “use a smarter model.” It is the loop above, on the app they actually want.
If you need the product built, not the workflow installed, that is the Build path.
Ship the list. Leave the extra folders out.
---
## Cara menggunakan Cursor AI tanpa bikin technical debt
URL: https://madebyaris.com/blog/cara-menggunakan-cursor-ai
Published: 2026-08-21. Updated: 2026-10-24.
Orang googling cara menggunakan Cursor AI, baca “suruh agent bikin fitur”, lalu Accept semua. Seminggu kemudian repo klien penuh package baru, utils2.ts di sebelah helper yang sudah ada, dan PR yang nggak ada yang berani review.
Itu bukan model yang bodoh. Itu cara pakai yang skip pagar.
Artikel ini pendamping bahasa Indonesia dari workflow yang sudah saya tulis di bahasa Inggris. Bukan tur fitur. Ini cara memakai Cursor tanpa nambah technical debt.
Kalau kamu baru kenalan, mulai dari Apa itu Cursor AI. Loop produksi lengkapnya, dalam bahasa Inggris, ada di How to use Cursor AI to ship faster without wrecking the codebase.
### Kenapa cara menggunakan Cursor AI tanpa pagar bikin utang
Cursor jago ngisi celah. Kalau kamu nggak kasih peta, dia isi dari tutorial Next.js di training data, bukan dari repo ini.
Tiga utang yang paling sering saya temui.
Package baru. Prompt “bikin modul invoice”. Rules kosong. Dia bikin packages/invoices-v2 padahal invoice sudah hidup di app/invoices. Tim nggak pakai folder itu. Satu bulan kemudian dua tempat nulis aturan yang sama.
utils2 dan duplikat. Helper CSV sudah ada. Dia nggak nemu, atau males nyocokin. Jadi lib/utils2.ts, exportCsvNew, atau api-client.ts di sebelah yang sudah dipakai. Namanya kelihatan rapi. Arsitekturnya pecah.
Diff yang nggak direview. Agent nulis 30 file. Summary-nya yakin. Kamu Accept karena deadline. Auth keubah, webhook ke-rename, tes baru cuma ngikutin implementasi. Review jadi mahal. Itu technical debt Cursor yang paling mahal: utang review.
Pagar itu project rules plus path di prompt plus kamu yang masih baca PR. Tanpa tiga itu, cara menggunakan Cursor AI cuma cara lebih cepat nambah utang.
### Empat kesalahan yang saya lihat di repo klien
Saya nggak ngarang ini. Ini pola dari kerjaan klien dan mentoring Cursor AI Indonesia.
Prompt tanpa path. “Tambah export CSV di invoice.” Nggak ada @. Nggak ada folder. Composer cari tempat. Sering tempat yang salah. Kalau kamu nggak bisa sebut app/invoices dan helper yang sudah ada, kamu belum siap generate.
Rules kosong, atau essay. File .cursor/rules nggak ada, atau isinya “tulis kode yang bersih” dan “ikuti best practice”. Model angguk, lalu tetap bikin package baru karena nggak ada yang bilang “jangan bikin package baru”. Pagar yang berguna: stack, peta folder, jangan invent, perintah tes. Setengah halaman. Detailnya di Project rules that stop Cursor from inventing bad architecture.
Skip review. Hijau di tes yang dia tulis sendiri bukan izin merge. Saya tetap baca diff kayak PR junior. Kalau dia nyentuh file yang nggak saya sebut, saya revert yang ekstra, ketatin scope, jalanin sekali lagi. Bukan “sekalian benerin itu”.
Apply from chat. Chat bagus buat tanya dan nge-plan. Kadang dia nawarin Apply. Di repo klien, Apply dari chat adalah jalan pintas ke utils2. Rencana di Chat. Tulis file lewat Composer dengan path yang sudah disebut. Pemisahan itu ada di Chat vs Composer in Cursor.
Kalau empat itu masih kebiasaan, kecepatan kamu palsu. Review tim yang bayar.
### Loop yang saya pakai: rules, Chat, Composer, review
Ini loop yang sama dengan pilar. Pendek.
- Project rules hidup. Setengah halaman. Stack, peta folder, jangan bikin package baru, bentuk error, perintah tes. Kalau rules-nya essay, anggap kosong.
- Chat buat rencana. Tanya di mana perubahan hidup. Minta path. Minta dia jangan nulis file dulu. Kalau saya nggak bisa sebut foldernya, mundur ke Chat. Jangan lompat ke Composer.
- Composer dengan file yang disebut. Buka file itu. @ path. Tulis blast radius: boleh sentuh apa, jangan sentuh apa. Baru generate.
- Tetap review PR. Rules kurangi folder invent. Mereka nggak nangkep aturan bisnis yang salah. Kamu tetap yang merge.
Kalau tugasnya repo berantakan, monorepo, folder yang nggak boleh disentuh, versi panjangnya ada di How to use Cursor AI effectively on a real repo.
Cursor AI Indonesia yang saya ajarin ke mentee bukan “agent lebih pintar”. Itu pagar plus urutan. Tab dan Chat dulu. Composer setelah rencananya muat lima kalimat. Review kayak kamu yang on-call.
### Prompt pendek yang saya pakai
Di atas rules file, prompt Composer saya kira-kira begini:
Tambah export CSV di list invoice. Ikuti project rules. Sentuh app/invoices dan lib/export saja. Jangan bikin package baru. Pakai helper CSV yang sudah ada. Jangan ubah webhook pembayaran. Acceptance: unit test baris CSV, termasuk list kosong.
Bahasa Indonesia atau Inggris, modelnya ngerti. Yang penting: path, yang dilarang, helper yang harus dipakai, cara tahu beres.
Kalau Chat, saya minta peta dulu:
Di app/invoices, filter list hidup di mana? Jangan usul file baru. Tunjuk helper yang sudah ada kalau ada.
Baru setelah path-nya jelas, pindah ke Composer.
### Checklist sebelum Accept
Sebelum generate:
- Rules file ada. Stack dan peta folder tertulis.
- Ada kalimat “jangan bikin package baru”.
- Chat sudah nulis rencana dan path. Composer nggak disuruh mikir dari nol.
- Saya sudah @ file yang boleh disentuh.
Sesudah Composer, sebelum Accept:
- Nggak ada folder top-level baru.
- Nggak ada package yang nggak saya minta.
- Nggak ada utils2 di sebelah helper asli.
- File di luar scope nggak keubah.
- Diff masih ukuran PR. Satu orang bisa selesaiin dalam satu duduk.
- Tes yang sudah ada jalan, bukan cuma tes yang baru dia tulis.
Kalau satu kotak gagal, revert yang ekstra, ketatin rules atau prompt, jalanin sekali lagi.
### Bukan lebih cepat. Lebih rapi.
Jadi, cara menggunakan Cursor AI yang nggak bikin technical debt itu bukan shortcut. Pagar dulu. Chat nge-plan. Composer dengan path. Review tetap kamu.
Model akan makin pintar. Repo klien tetap berantakan dengan caranya sendiri. Kerjaan kamu: pagar dan selera.
Kalau kamu mau dibantu pasang loop itu di repo sendiri, bukan cuma dikasih daftar fitur, itu Level up. Saya mentoring Cursor buat developer yang sudah nge-code dan mau nge-ship tanpa ngerusak codebase.
Install pagar. Pilih permukaan. Review kayak kamu yang pegang on-call.
---
## Project Rules That Stop Cursor Hallucinations
URL: https://madebyaris.com/blog/cursor-project-rules
Published: 2026-08-20. Updated: 2026-10-24.
People paste “build me an invoices module” into Cursor with empty project rules, then they get a new package, a new utils folder, and an architecture nobody on the team uses.
That is not a smarter model problem. That is a missing fence.
This post is the fence: .cursor/rules, or the older .cursorrules file. Short, local, boring.
The full production loop is here: How to use Cursor AI to ship faster without wrecking the codebase. The messy-repo version is How to use Cursor AI effectively on a real repo. After the fence, pick the surface: Chat vs Composer in Cursor. A cursor ai workflow that survives a client repo starts with rules.
### Why Cursor invents architecture
Cursor is helpful. Helpful without a map invents.
Three setups I still see:
No fence. You open the repo, skip rules, and type “build me X.” The model fills gaps from training data. That is a greenfield Next.js tutorial, not this codebase. New folders. New packages. A lib/api-client.ts next to the one you already have.
Empty or essay rules. A file that says “write clean code” and “follow best practices.” The model nods and still creates packages/invoices-v2 because nothing said “do not create packages.”
A wish with no paths. “Add export on invoices.” No @. No folder map. Composer (or Agent) will find a place. Often the wrong place.
The model is not rebellious. It completes a pattern. If the repo does not name the pattern, it picks one. Project rules name it once.
### What belongs in a project rule
I keep rules on half a page. If I cannot read them in a minute, Cursor will not either.
What I actually put in:
Stack. Next.js App Router, TypeScript, pnpm, Tailwind, whatever is true here. I have watched it invent a lockfile in a pnpm repo because nobody said pnpm.
Folder map. Where routes live. Where UI primitives live. Where shared helpers live. Real paths, not “the feature folder.” If this app is app/ and the helper is lib/, I write those strings.
Do not create new packages. Or new top-level folders. If a helper is missing, ask. Prefer the existing lib/ over a new utils/. This line has saved me more diffs than any style guide.
Error and API shapes. { error: string, code?: string } or whatever the nearby route already returns. “Handle errors well” is not a shape. A shape is copy-pasteable.
Naming. Kebab-case files. PascalCase components. Match the sibling.
Test command. pnpm test. Tests next to the module as *.test.ts, if that is what we do. If I skip this, it will skip tests or invent a Jest config in a Vitest repo.
### What I leave out
I do not paste a 2,000-line style guide into .cursor/rules.
The model half-reads long files. It will remember “be clean” and forget “do not touch billing.” The long file also drifts. The repo changes. The essay does not.
Out:
- A manifesto about clean architecture
- Opinions the formatter already owns
- A history of the company
- “Always write beautiful, production-ready code”
- Every lint rule, copied from the linter
If a convention is local to one package, I say it in that ticket, not in global rules.
Good rules stop random creativity. They do not make Cursor brilliant. You still have to scope the ticket.
### A rules file I would actually commit
Generic Next.js app. I drop this in .cursor/rules and stop typing.
```
# Project rules
Stack: Next.js App Router, TypeScript, pnpm, Tailwind.
Folders:
- Routes: app/
- UI primitives: components/ui. Reuse these. Do not invent a new button.
- Shared helpers: lib/
- Do not create a new package or a new top-level folder.
If a helper is missing, ask before creating it. Prefer lib/ over a new utils/.
API errors: { error: string, code?: string }. Match the nearby route handler.
Naming: kebab-case files, PascalCase components. Match the sibling file.
Tests: pnpm test. Colocate as *.test.ts.
Do not change schema, auth, or payments unless the prompt names those files.
No drive-by refactors.
```
Half a page. Extra goes in the prompt or next to the code.
### Rules, then Chat, then Composer
Rules are the standing fence. They do not replace a scoped prompt.
My loop on client work:
- Rules exist and fit on half a page.
- Chat finds where the change lives. Plan only. Name paths. Do not write files yet. Same split as Chat vs Composer in Cursor.
- Open those files. @ them. Run Composer with a blast radius.
- Still read the PR. Rules reduce invented folders. They do not catch a wrong business rule.
A prompt I actually use, on top of the rules file:
Add CSV export on the invoices list. Follow project rules. Touch app/invoices and lib/export only. Do not create a new package. Reuse the existing CSV helper.
Composer without rules and without named files is Chat with write access. That is the 30-file diff. Rules plus Chat plus a fenced Composer job is the cursor ai workflow I trust.
If I cannot name the folders, back to Chat. More on that habit: effective-on-a-real-repo.
### Checklist I actually use
Before I generate:
- Rules file exists. It names the stack and the folder map.
- It says “do not create new packages” in plain words.
- Error shape and test command are in there, not in my head.
- I am not asking Composer to think. Chat already did the plan.
After Composer:
- No new top-level folder.
- No new package I did not ask for.
- No duplicate helper next to the real one.
- Diff is still PR-sized. I can finish it in one sitting.
If a box fails, I revert the extra, tighten the rule or the prompt, and run once more.
### What I tell mentees
Install the fence first. Then pick the surface. Then review like you own the on-call.
I coach this in Cursor mentoring when a team keeps getting invented architecture. The fix is almost never “use a smarter model.” It is a half-page of rules, then Chat to plan, then Composer with named files.
Most people who ask me about project rules just need the file above, on their actual repo, once. If the team needs that workflow installed, that is the Level up lane. I sit with the real repo, not a toy app.
---
## Cursor Chat vs Composer: When to Use Each Surface
URL: https://madebyaris.com/blog/chat-vs-composer-in-cursor
Published: 2026-08-19. Updated: 2026-10-19.
When developers first switch to Cursor, they often treat Cursor Chat and Composer (or Agent mode) as interchangeable tabs in the same interface. Then a “simple” feature request results in an uncontrolled 25-file diff, breaking shared utilities and introducing subtle bugs across the repository.
Both surfaces connect to the same powerful language models, but they operate under entirely different contracts. Choosing the wrong surface for the task at hand is one of the most common causes of technical debt in AI-assisted development.
Here is how I choose between Chat and Composer in daily client work, with the exact prompt structures and guardrails I use to keep production pull requests clean and maintainable.
### The Core Difference: Exploration vs Execution
The clearest way to think about the two modes is simple:
- Cursor Chat is your senior architectural consultant. It reads context, explains unfamiliar code, brainstorms design patterns, and diagnoses complex errors without touching your disk.
- Cursor Composer is your implementation assistant. You provide a clearly scoped plan, specify boundary files, and let it draft edits across multiple files in a single pass.
Dimension | Cursor Chat | Cursor Composer / Agent |
Primary Objective | Investigation, planning, debugging | Multi-file code implementation |
Disk Access | Read-only (generates text snippets) | Read & write (directly proposes diffs) |
Scope of Input | Focused questions with targeted @ references | Well-defined specifications with boundary constraints |
Output Format | Explanations, suggested patterns, markdown | Inline side-by-side file diffs ready to review |
### When to Use Cursor Chat
Stay in Cursor Chat whenever you do not yet know the exact architecture or files involved in your task:
- Investigating unfamiliar repositories: Ask Chat to locate where a specific business rule, authentication flow, or API webhook handler resides.
- Formulating an implementation strategy: Before modifying code, ask Chat to propose the minimal set of changes required to fulfill a requirement.
- Interpreting cryptic error traces: Paste complex runtime errors or failing CI logs into Chat along with the relevant function file.
- Code review sanity checks: Paste a critical algorithm and ask Chat to spot potential edge cases or security vulnerabilities.
A practical Chat prompt formula:
“In @app/services/invoicing, where does invoice status state transition happen? Do not write code or create new files. Point me to the existing helper and explain how it handles failures.”
### When to Use Cursor Composer
Switch to Composer only after the plan is settled and you can name the exact files to be updated:
- Scoped multi-file refactoring: Updating a data model and simultaneously updating its validation schema and unit tests.
- Implementing new API routes: Creating a new endpoint handler along with its corresponding client fetch function.
- Boilerplate component scaffolding: Creating a new UI component while matching existing design system conventions.
A practical Composer prompt formula:
“Add CSV export functionality to the invoices table. Modify only @app/invoices/page.tsx and @lib/export.ts. Do not touch billing or webhook utilities. Match the error handling pattern in @app/users/page.tsx.”
### The Four-Step Workflow for Clean PRs
To avoid massive diffs and keep code reviews effortless for your team, follow this sequential loop:
- Plan in Chat: Refine the solution until the plan is concrete and the target files are identified.
- Fence in Composer: Open Composer and explicitly reference only the target files using “@” tags while explicitly forbidding modifications outside that boundary.
- Review the diff critically: Treat every line Composer produces like code written by a junior developer. Watch out for deleted comments, unexpected dependencies, or hallucinated utility functions.
- Verify locally: Run tests, linters, and type checking before committing.
### Common Traps to Avoid
1. Pressing “Apply” directly from Chat on complex tasks. While Chat has an “Apply” button, it lacks multi-file awareness. Applying multi-file ideas from Chat frequently creates duplicate files (such as utils2.ts).
2. Leaving Composer unconstrained on monorepos. If you do not constrain Composer to a specific package or folder, it will happily refactor shared root libraries to solve a local component problem.
3. Trusting the model’s self-written summary. AI models generate confident, persuasive PR summaries. Always inspect the actual git diff rather than accepting the summary at face value.
### Next Steps for Your Workflow
Mastering the boundary between Cursor Chat and Composer is the difference between writing clean, sustainable software and building an unmaintainable codebase.
If you want to train your engineering team on practical, production-ready AI coding workflows, check out my Cursor mentoring and team coaching programs.
---
## How to Use Cursor AI Effectively on Real Repos
URL: https://madebyaris.com/blog/how-to-use-cursor-ai-effectively
Published: 2026-08-18. Updated: 2026-09-24.
Most tutorials on using Cursor AI showcase clean, greenfield toy applications: an empty directory, a fresh Vite setup, and a prompt asking the model to build a todo app. In that controlled environment, Cursor looks like magic.
Production engineering is never greenfield. It is an established repository with three years of git commits, two legacy packages nobody wants to touch, local state conventions, and sensitive billing pipelines. If you point an AI agent at a production codebase without strict boundaries, it will happily introduce duplicate utilities, overwrite established patterns, and leave you with unmanageable technical debt.
Here is how I use Cursor AI effectively on real client repositories, based on over 13 years of shipping web applications and coaching engineering teams as a Cursor Ambassador.
### 1. Establish Strict Project Rules (.cursor/rules)
Without explicit instructions, language models default to generic internet patterns rather than your team’s established architecture. Cursor’s modern rule system (located in .cursor/rules/*.mdc) lets you set persistent guardrails that apply automatically across files.
Here is an example rule configuration that prevents common hallucinations in a Next.js App Router codebase:
```
---
description: Next.js App Router and TypeScript standards
globs: app/**/*.{ts,tsx},lib/**/*.{ts,tsx}
alwaysApply: false
---
# Architecture Standards
- Always prefer Server Components by default.
- Never add 'use client' unless client hooks (useState, useEffect, useSearchParams) or browser event listeners are strictly required.
- Do not create generic 'utils.ts' or 'helpers.ts' files. Colocate utilities near their domain feature.
- Use existing UI primitives from '@/components/ui' rather than installing new third-party packages.
- When creating form submissions, use Server Actions in '@/app/actions' rather than custom API routes.
```
Having targeted rule files scoped by glob patterns ensures that the model only receives the instructions relevant to the specific file it is editing, preventing context bloat.
### 2. Fence Your Context with Surgical Precision
The single biggest mistake developers make is typing @codebase for routine tasks. Broad context dumps confuse the model, inflate your token costs, and result in unwanted edits across unrelated packages.
Instead, follow the principle of least context:
- Reference exact files: Tag only the specific files directly involved (e.g., @app/invoices/table.tsx and @types/invoice.ts).
- Reference reference patterns: When creating a new feature, point the model to an existing sibling component as a template: “Implement the customer list matching the patterns in @app/users/table.tsx.”
- Explicitly declare what is off-limits: Always include negative constraints in multi-file prompts: “Do not touch authentication middleware or billing packages.”
### 3. Separate Planning from Implementation
Do not ask Cursor Composer to jump straight into modifying code on non-trivial tasks. Use a two-phase workflow:
Phase 1: Explore and plan in Chat. Interrogate the codebase and ask Chat to produce a concise, numbered implementation checklist. Challenge any step that looks unnecessarily complex or touches shared code.
Phase 2: Execute in Composer. Once the plan is verified, feed that exact checklist into Composer alongside the specific file tags. This keeps Composer focused on executing an approved blueprint rather than improvising architecture.
### 4. Audit the Diff Like a Senior Engineer
Cursor Composer writes polite, convincing pull request descriptions. Never merge a change based on the model’s written summary. When reviewing an AI-generated diff, check for these four silent issues:
- Disappearing comments and types: Models frequently strip helpful docstrings or TypeScript type definitions during broad refactors.
- Sneaky package additions: Check your package.json to ensure the agent did not install an unnecessary dependency for something easily solved in native code.
- Duplicate logic: Confirm the agent did not recreate an existing helper under a slightly different name because it did not find the original.
- Skipped error handling: Verify that try/catch boundaries, loading states, and edge cases are handled rather than glossed over.
### Summary: The Sustainable Cursor Loop
Effective use of Cursor AI is not about generating the maximum number of lines in the shortest amount of time. It is about keeping PRs small, context narrow, and code quality high enough that your teammates can review and maintain the work with complete confidence.
If you want hands-on support introducing Cursor to your engineering team with proven rules and review habits, learn more about my Cursor mentoring and team coaching services.
---
## A Cursor AI tutorial for beginners who already ship code
URL: https://madebyaris.com/blog/cursor-ai-tutorial-for-beginners
Published: 2026-08-17. Updated: 2026-08-18.
Most cursor ai tutorial for beginners posts assume you just learned to code. You didn’t. You already review PRs, and you just installed Cursor because the people around you are shipping faster this month.
This is the first-week version I give those people. Install, open a real repo, then run the same four steps until they feel boring.
I’m Aris Setiawan. Senior full-stack, first Cursor Ambassador in Indonesia. I ship client work in Cursor every week, and I coach this habit in Level up. The longer production version lives in How to use Cursor AI to ship faster without wrecking the codebase.
### Who this is for
This is for you if:
- You already write production code and you can review a diff without a tutorial.
- You opened Cursor this week and the agent feels faster than your judgment.
- You want a first-week loop you can run on a client repo, not a toy todo app.
This is not for you if you want “how to code with AI from zero.” I will not teach JavaScript. I will teach how to keep Cursor from inventing a second architecture inside a repo you already own. Beginner here means beginner at Cursor, not beginner at shipping.
### Install, open, then stop clicking around
Download Cursor from cursor.com. Install it. Open the repo you actually work in. Sign in. Pick a paid plan if this is client work. Hobby is fine for a weekend poke.
Then stop touring the UI.
You need three things on day one:
- The chat panel, for thinking.
- Agent (Composer), for a scoped diff.
- The habit of opening files yourself instead of dumping the whole monorepo into context.
Tab autocomplete will start helping while you type. Leave it on. Do not start week one by asking the agent to “improve the codebase.” That is how you spend Friday reverting Monday.
Rules and MCP can wait. Week one is a loop, not a setup rabbit hole.
### The first week loop: plan, scope, generate, review
This is the only loop I want you to practice for seven days.
1. Plan. Write five sentences before you generate anything. What changes for the user? Which folders are in play? What is off-limits? How will you know it worked? If you cannot write that, you are not ready for the agent.
2. Scope. Open the files yourself. @ those paths. Name the files you will not touch. Broad context invites a broad diff. A broad diff is what you cannot review after lunch.
3. Generate. Ask the agent for one slice, not the whole feature. Types and a failing test first, or the helper plus the wire-up. Not “build invoice export and also clean up billing.” Match existing patterns. No drive-by refactors.
4. Review. Read the diff like a fast junior wrote it, because that is the honest mental model. Does it match the plan and only the plan? New deps you did not ask for? A second helper that already exists? Secrets in a log line? Reject the extra.
Then test the path that would fail if the behavior were wrong. Commit like a human. Repeat tomorrow on a smaller slice. Same four steps, smaller scope, until the agent feels like a pair.
### Chat vs agent, one short split
Chat is for decisions. Agent is for a diff.
Use chat when you want options, a stack-trace read, or a plan you can argue with. Use the agent when the plan is already written, the files are already open, and you want something you can review.
A week-one pattern that does not get people in trouble:
- Chat: agree on the approach in five sentences.
- Agent: implement only that slice.
- You: read the diff. Reject anything that wandered.
- Chat again only if the riskiest bit is unclear.
If you skip the chat plan and jump straight to “implement export,” you will get a tour of files you never meant to open. I wrote the longer split in the production Cursor workflow. Week one, just remember: think in chat, type in the agent.
### One small example: invoices CSV
Say the invoices list needs a CSV download. Do not type “add export.” Do this.
Plan. Add CSV export on the invoices list. Touch only app/invoices and the existing export helper if there is one. Do not change payment webhooks or the invoice PDF path. Acceptance: a unit test for the row shape, plus a manual download on staging.
Scope. Open the list page, the invoice query, and the current export helper. @ those three. Tell the agent those are the only targets.
Generate. Ask for the row mapper, the download handler, and a test that checks headers plus one sample row. Reuse the helper. Do not invent exportUtils2.ts. Do not restyle the table.
Review. Check date formatting against the UI. Check that unpaid invoices still export. Check that the handler does not pull fields you never show the user. Run the test. Click the button once. Commit: Add CSV export for the invoices list.
That is a first-week task. One behavior. One folder. One review. If the agent also “helpfully” rewrites the invoice status badge, you revert that part and you tighten the prompt next time.
### Mistakes new Cursor users make
I see these in the first ten days, including from seniors.
Asking for the whole feature. You get a 40-file diff. You skim. You merge. You spend next week finding the middle.
Treating the agent as a search bar for architecture. If the repo already has an export helper, say so. New patterns need a decision, not a surprise file.
No off-limits list. Without “do not touch webhooks,” the agent will touch webhooks. It is being helpful.
Reviewing the summary, not the diff. Confidence is cheap. Read the files.
Letting AI-written tests be the only proof. Tests that mirror the implementation will nod along. Add one case that would fail if the behavior were wrong: empty list, a timezone, a permission you forgot.
Measuring the week by how much the agent wrote. Measure by PRs you can review in one sitting, and by how few you revert.
Those are first-week habit problems, not model problems. The fix is the loop, not a smarter prompt pack.
### Do the loop for a week, then go deeper
A cursor ai tutorial for beginners who already ship code should end the same way a good first week ends: you still own the decisions.
Do the loop until it is boring. Then read the longer version: How to use Cursor AI to ship faster without wrecking the codebase. That is the production loop with tests, commits, rules, and team habits.
If you want a second pair of eyes while you install the habit on your repo, that is Level up. I will not sit through a UI tour with you. I will sit through your next messy PR and tighten the loop.
---
## Apa itu Cursor AI? Penjelasan praktis buat developer
URL: https://madebyaris.com/blog/apa-itu-cursor-ai
Published: 2026-08-16. Updated: 2026-09-24.
Orang googling apa itu Cursor AI, baca “AI buat nulis kode”, lalu install. Seminggu kemudian repo-nya berantakan dan review makin lama.
Cursor bukan ChatGPT yang kebetulan bisa nge-code. Cursor itu editor. Kamu buka folder proyek, sama seperti VS Code. Bedanya: AI-nya sudah duduk di editor itu, lihat file yang kamu buka, dan bisa nulis atau ngubah kode di tempat.
Artikel ini Ini jawaban praktis: apa itu, tiga hal yang dia lakukan, siapa yang cocok, dan salah paham yang sering saya dengar.
### Cursor itu editor, bukan chatbot di browser
Kalau kamu buka ChatGPT atau Claude di browser, kamu copy-paste potongan kode, dapat jawaban, copy balik. Konteksnya sebatas yang kamu tempel. Repo-nya nggak kelihatan. Git-nya nggak kelihatan. File yang belum kamu buka ya belum ada di percakapan.
Cursor kerja sebaliknya. Kamu buka repo. Ada explorer, terminal, git, search, kayak editor biasa. AI-nya nempel di situ. Dia bisa baca file yang kamu tunjuk, lihat folder yang kamu scope, dan nulis perubahan langsung ke disk.
Itu beda yang penting. Chatbot di browser bantu mikir. Cursor bantu kerja di proyek. Kalau kamu cuma butuh tanya “kenapa hook ini re-render”, chatbot cukup. Kalau kamu mau ubah tiga file di app/invoices tanpa keluar dari editor, itu kerjaan Cursor.
Cursor dibangun di atas fondasi VS Code. Shortcut dan extension ikut. Yang berubah: tab buat lengkapi baris, chat buat tanya proyek, agent buat eksekusi setelah rencananya jelas.
### Tiga hal yang dilakukan Cursor AI
Saya sederhanakan ke tiga pekerjaan. Sisanya turunan.
1. Lengkapi kode (tab / autocomplete).
Kamu ngetik. Cursor nawarin kelanjutan. Kadang satu baris, kadang satu blok. Ini yang paling sering saya pakai, dan yang paling aman. Kamu lihat, terima atau tolak, lanjut. Cocok buat boilerplate dan test case yang polanya sudah kelihatan.
Jangan treat tab sebagai “benar”. Treat sebagai draf cepat. Kalau namanya aneh atau dia nyentuh auth tanpa diminta, tolak.
2. Chat di proyek.
Kamu tanya soal file yang lagi dibuka, atau folder yang kamu @. “Kenapa fetch ini dipanggil dua kali.” “Di mana validation invoice hidup.” “Tolong jelasin flow webhook-nya, jangan ubah apa-apa.”
Chat bagus buat ngerti, nge-plan, dan nge-review. Saya jarang minta chat nulis fitur utuh. Saya minta dia bantu nulis rencana dulu: file mana yang boleh disentuh, apa yang nggak boleh berubah, gimana saya tahu itu beres.
3. Agent ubah banyak file.
Setelah rencananya jelas, baru agent. “Tambah CSV export di list invoice. Sentuh app/invoices dan helper export yang sudah ada. Jangan ubah payment webhook. Acceptance: unit test baris CSV.”
Agent bisa bikin diff di beberapa file sekaligus. Itu kekuatannya, dan itu juga risikonya. Tanpa scope, dia seneng nambah utility baru, sentuh config, atau “sekalian” merapikan yang nggak diminta. Saya cuma lepas agent kalau batasan sudah muat lima kalimat.
Tiga hal itu urutannya penting. Tab dulu. Chat buat nge-plan. Agent terakhir. Kebanyakan orang yang kecewa sama Cursor kebalik: langsung agent, baru mikir.
### Siapa yang cocok (dan siapa yang jangan dulu)
Cursor cocok buat developer yang sudah nge-code. Orang yang bisa baca diff, tahu kapan tesnya bohong, dan berani tolak saran yang kelihatan pintar tapi salah.
Kalau kamu sudah biasa review PR, Cursor ngerasa kayak rekan yang ngetik cepat. Kamu tetap yang merge. Kamu tetap yang tanggung jawab.
Kurang cocok kalau yang dicari adalah shortcut tanpa review. “Suruh AI bikin app, saya cuma pencet Accept.” Itu demo weekend, bukan cara kirim kerjaan klien. Saya sudah lihat hasilnya: helper misterius, auth keubah tanpa alasan, dan dua minggu cleanup.
Kalau kamu masih belajar dasar (variable, git, cara baca error), belajar itu dulu di editor biasa. Cursor nggak ganti fondasi. Dia percepat habit yang sudah ada. Habit rapi jadi lebih rapi. Habit berantakan jadi mahal.
### Salah paham yang sering saya dengar
“Cursor itu ChatGPT di dalam VS Code.”
Hampir, tapi nggak. Model-nya bisa ganti. Yang penting dia duduk di repo: file, folder, git, terminal. ChatGPT di browser nggak pegang itu kecuali kamu tempel.
“Kalau hijau, berarti beres.”
Tes hijau-ish bukan izin merge. Agent jago bikin tes yang ikut implementasinya, bukan yang nangkep regresi. Saya tetap baca diff. Saya tetap jalanin tes yang sudah ada, bukan cuma yang baru dia tulis.
“Tinggal suruh agent, saya ngopi.”
Agent tanpa rencana itu junior yang percaya diri. Cepat, luas, sering nyasar. Kalau kamu nggak bisa jelasin scope-nya, jangan lepas dia ke repo klien.
“Pakai Cursor berarti saya nggak perlu ngerti kodenya.”
Kebalik. Kamu harus lebih jago baca kode orang lain, karena sebagian besar hari kamu review draf. Kalau nggak ngerti hasilnya, jangan merge.
“Ini buat yang belum bisa nge-code.”
Bukan. Paling berguna di tangan orang yang sudah bisa nulis sendiri. Kalau fondasinya belum ada, yang ke-generate cuma utang.
“Semua harus lewat AI.”
Nggak. Rename satu component, saya kerjain sendiri. Bug yang sudah jelas lokasi filenya kadang lebih cepat tanpa chat. Cursor itu opsi, bukan agama.
### Yang saya lakukan di kerjaan klien
Pola saya pendek:
- Tulis rencana dalam bahasa biasa.
- Buka file yang relevan, @ path itu, jangan dump monorepo.
- Tab dan chat dulu.
- Agent hanya setelah batasan jelas.
- Review diff kayak PR orang lain. Tolak yang di luar scope.
- Tes. Commit kecil.
Kalau langkah 1 nggak muat lima kalimat, saya belum siap generate. Cursor jago ngisi celah. Dia jelek baca pikiran soal constraint produk.
Versi panjang workflow ini, dalam bahasa Inggris, ada di How to use Cursor AI to ship faster without wrecking the codebase. Itu pilar Level up-nya. Artikel ini cuma pintu masuk: apa itu Cursor AI, tanpa tur fitur.
### Bukan shortcut. Editor plus kebiasaan.
Jadi, apa itu Cursor AI? Editor kode dengan AI di dalamnya. Bukan chatbot di tab sebelah. Dia lengkapi baris, jawab pertanyaan soal proyek, dan (kalau kamu izinkan) ubah banyak file sekaligus.
Yang bikin dia berguna bukan modelnya. Yang bikin berguna adalah kamu tetap review, tetap scope, tetap tes. Tanpa itu, kamu cuma lebih cepat bikin utang.
Kalau kamu mau dibantu pasang habit itu di repo sendiri, bukan cuma dikasih daftar fitur, itu kerjaan Level up. Saya mentoring Cursor buat developer yang sudah nge-code dan mau nge-ship tanpa ngerusak codebase.
Kalau kamu baru penasaran, install, buka repo yang kamu kenal, dan pakai tab dulu. Chat belakangan. Agent terakhir. Itu urutan yang jarang bikin sesal.
---
## Cursor AI vs Copilot: what I pick for client work
URL: https://madebyaris.com/blog/cursor-ai-vs-copilot
Published: 2026-08-15. Updated: 2026-08-18.
People treat cursor ai vs copilot like a brand war. Pick a side. Post a screenshot. Argue about models.
I don’t. I treat it as a job split.
I’m Aris Setiawan. Senior full-stack, first Cursor Ambassador in Indonesia. I ship client work every week. Some weeks I live in Cursor. Some weeks Copilot is enough and opening another editor would just slow the PR. The question is not “which tool is better.” The question is which job you are doing today.
### What each tool is actually good at
Cursor and Copilot overlap on autocomplete. That is where the brand war starts, and it is the least useful part of the comparison.
Cursor is the repo tool. Agent, multi-file edits, chat that can see the project. I point it at paths, I ask it to implement a slice, I get a diff across several files. Repo chat is how I ask “where does invoice status actually change?” without grepping for twenty minutes. The agent is how I implement that answer once I have scoped it. That is the product I pay for. Tab is a bonus.
Copilot is the inline tool. It lives in VS Code, and in the other editors people already have. It completes the line you are in, the function you started, the test you were going to write anyway. You stay in flow. You do not context-switch into an agent panel. You do not wait for a multi-file plan. If the job is “keep typing, fill in the obvious,” Copilot is still very good at that job.
I wrote the production habit in How to use Cursor AI to ship faster without wrecking the codebase. The short version: plan, scope, generate, review, test, commit. Cursor is built for that loop. Copilot is built for the moment inside that loop when your hands are already on the keyboard.
Neither one reviews the PR for you. Neither one knows the client’s billing edge cases unless you tell it. The tool does not replace taste.
### When I pick Cursor vs Copilot for client work
I pick Cursor when the change is a slice, not a line. New export on the invoices list. A refactor that touches a helper and three callers. A bug that lives in two packages. I need the agent to hold the plan, I need repo chat to find the call sites, I need a multi-file diff I can actually review. That is client work I will not do with Tab alone.
I pick Cursor when I do not know the repo yet. First week on a client codebase. I ask chat where auth happens, where the queue is wired, which test file owns this behavior. Grep still works. Repo chat is faster when the names are lying.
I pick Cursor when I am mentoring. If I am teaching a team a habit, I want one editor that can do chat, agent, and rules in the same place. I already wrote the plain-English bill in Cursor AI pricing. You pay for a seat and a usage pool. Spend that pool on the work that needs an agent, not on renaming a button.
Copilot is enough when I am already in VS Code and the work is local. A component I know. A test I can write from memory. A CSS tweak. A types fix. I do not need an agent to complete a map or to stub the next assertion. Opening Cursor for that is ceremony.
Copilot is enough when the team already standardized on VS Code and will not move. I do not start a religious war in week one of an engagement. If they have Copilot, I use Copilot for inline work and I keep Cursor on my machine for the slices I own. I do not force a migrate-the-editor project unless the agent work is the actual bottleneck.
Copilot is enough when I am pairing on a tiny change in someone else’s session. Their laptop, their VS Code, their Copilot tab. I am not going to install Cursor mid-call so we can rename a prop.
The split is boring on purpose. Cursor for scoped, multi-file, “I need the repo in the conversation” work. Copilot for inline complete in the editor you already have.
### What I tell teams (don’t run both badly)
The failure I see is not “they picked the wrong logo.” It is two tools, no default, and nobody reviewing the diffs.
Don’t run both badly.
If everyone has Copilot and two people also have Cursor, you will get two styles of AI code in the same PR. One person accepts a 20-file agent pass. The next person tabs through a function and ships a different naming style. Reviewers cannot tell what was intended.
Pick a default.
- Default to Copilot if the team lives in VS Code, most work is local, and nobody is running agents yet.
- Default to Cursor if the team already wants an agent loop, you will write project rules, and you will review diffs like you mean it.
- Allow the other tool for a reason you can say out loud. “I used Cursor because this slice crossed three packages.” Not “I felt like it.”
Rules I give the same week:
- One owner per change. If an agent drafted it, that person can explain every file.
- Scope the context. Don’t paste the monorepo into a rename.
- Review like a human wrote it. Because you will maintain it.
- Don’t stack autocomplete from two vendors on the same buffer. You will accept the louder suggestion, not the right one.
- Budget the agent. Cursor usage is a pool. I covered that in the pricing post. Burning frontier models on boilerplate is how teams get a surprise bill and still ship messy code.
If you want help installing that habit, that is Level up. I sit with the team, we pick a default, and we practice the loop on a real repo. Not a slide deck.
### Split the job, don’t pick a side
Cursor AI vs Copilot is a boring decision once you stop treating it as a fandom.
Use Cursor when you need an agent, a multi-file diff, or a chat that can see the repo. Use Copilot when inline complete in VS Code is the whole job. Use neither as an excuse to skip review.
If you want the production loop I run inside Cursor, start with How to use Cursor AI to ship faster without wrecking the codebase. If you want the plain-English bill before you buy seats, read Cursor AI pricing.
If you want a second pair of eyes on the workflow, I do that in Level up / Cursor mentoring.
---
## Cursor AI pricing in 2026: what you actually pay
URL: https://madebyaris.com/blog/cursor-ai-pricing
Published: 2026-08-14. Updated: 2026-10-19.
Cursor costs $0 to $200 a month for one person and starts at $30 per seat for teams. The paid plans are Plus at $8, Premium at $30, Super at $100, and Ultra at $200, and any third-party model you use in Cursor, such as Claude or GPT, is billed on top at API list price.
Prices checked on October 14, 2026 on cursor.com/pricing. They exclude taxes such as VAT. Cursor changes its plans often, so check that date before you budget from this page.
As the first Cursor Ambassador in Indonesia, the question I hear most from founders, engineering leads, and freelancers is: how much will Cursor cost my team each month? The seat price is the easy part. The surprise on the bill comes from which models people pick and how they run agents.
### How Cursor pricing works now
Since Cursor joined SpaceX in August 2026, every plan draws from one usage pool shared across Cursor and Grok. Three things decide your bill:
- The plan fee. A fixed monthly price per person, or per seat on Teams.
- The included usage pool. Higher plans get a bigger pool, measured against Plus. It refreshes every week, so one heavy day does not wipe out your month. Grok Chat, Imagine, and Voice draw from the same pool.
- Third-party models. Premium and above can use models outside Grok in Cursor, but no plan includes an allowance for them. You pay API list price for every call.
When you use up the included pool, you can buy top-offs or wait for the weekly refresh. Your remaining usage is always visible in Cursor’s settings.
### Cursor plans for individuals
#### Free ($0 a month)
Limited agent and chat requests. Enough to try the editor on a side project. Too little for client work with a deadline.
#### Plus ($8 a month)
Basic usage and Grok models only. Cursor recommends Plus for social creators with light AI use. For coding I treat it as a cheap way to keep using Cursor, since you cannot switch to a third-party model when a task gets hard.
#### Premium ($30 a month)
4x the usage of Plus. It adds cloud agents and automations, code hosting through Origin, AI code reviews through Bugbot, and third-party models at API list price. Cursor recommends Premium for people new to AI coding, and it is where I tell most developers to start.
#### Super ($100 a month)
15x the usage of Plus, plus priority model access at peak times. Cursor’s pick for people who run agents every day.
#### Ultra ($200 a month)
50x the usage of Plus and the earliest access to new products and models. Cursor’s pick for power users who run long or parallel agent sessions.
### Cursor pricing for teams
Teams starts at $30 per user a month. Each seat gets 4x to 50x the usage of Plus depending on its seat tier, and you can mix seat types on one team. On top of the individual features, Teams adds:
- Centralized billing and administration.
- Usage analytics in the admin dashboard.
- Team-wide privacy settings and custom chat data retention.
- SAML and OIDC single sign-on.
- A team marketplace for internal rules, skills, and plugins.
Enterprise is a custom contract. It adds pooled usage, invoice or PO billing, SCIM seat management, audit logs, granular spend limits by group, and access controls for repositories, models, and MCP servers.
### The part of the bill people miss: third-party models
The plan price covers Grok models. If your team prefers Claude or GPT for some jobs, that usage is billed separately at the provider’s API list price, on every plan, with nothing included. Five people on $30 seats pay $150 a month before a single third-party model call.
That is where budgets drift. Decide which jobs deserve a third-party model, and set a spending cap before the first long agent run.
For a number that fits your team, use my Cursor cost estimator. Pick a team size and how hard people lean on agents, and it suggests a plan and a monthly total from the same prices as this post.
### What drives your cost on client work
In client work and team coaching, I rarely see a bill grow because of the seat price. It grows because of agent habits:
1. Dumping the whole codebase into context. Pointing an agent at a large monorepo with no file boundaries sends huge context windows. It burns usage fast, and the diffs often get worse because the model gets distracted by unrelated files.
2. Paying API list price for mechanical work. Renaming variables or formatting a CSS file on a third-party frontier model is money you did not need to spend. Keep those models for architecture calls, hard migrations, and difficult debugging.
3. Unfenced agent loops. Ask an agent to “make this work” without naming the files it may touch, and it will go through round after round of edits, tests, and errors, spending usage on every pass.
### Four habits that keep the bill predictable
- Fence your context. Reference only the two or three files the change needs instead of the whole repository.
- Set a spending cap early. Cap third-party model spend before anyone needs it, so a long agent run cannot surprise you.
- Use project rules. A clean .cursor/rules/*.mdc file stops the agent from installing packages you do not need or inventing duplicate helpers. You can download mine from the Cursor rules library.
- Check usage midweek. The allowance refreshes weekly, so look at your remaining usage in settings around Wednesday instead of waiting for the invoice.
### Frequently asked questions
#### How much does Cursor cost per month?
Free is $0, Plus is $8, Premium is $30, Super is $100, and Ultra is $200 a month. Teams starts at $30 per user a month, and Enterprise is a custom contract. Third-party model usage and taxes are extra.
#### Which Cursor plan should I pick?
Cursor recommends Premium if you are new to AI coding, Super if you run agents every day, and Ultra if you are a power user. My advice: start on Premium, watch how often you hit the weekly limit for two weeks, and move up only if you keep hitting it.
#### Are Claude and GPT included in Cursor plans?
No plan includes an allowance for third-party models. On Premium and above you can still use them in Cursor, billed separately at API list price. Plus is limited to Grok models.
#### Does the Cursor usage limit reset monthly?
It refreshes weekly. If you run out before the refresh, you can buy top-offs or wait.
#### Will Cursor train on my code?
Turn on privacy mode in settings, or have a team admin turn it on for everyone. With privacy mode on, Cursor guarantees your code data is not used for training by Cursor or its model providers.
### Helping your team ship with Cursor
Buying Cursor seats is easy. Getting a team to write clean, reviewable code with it takes deliberate habits: repo rules, prompt guardrails, and a review standard for AI-written diffs. My Cursor guide collects what I use.
If you want me to set those up with your team, see Cursor mentoring for teams.
---
## Ship Faster with Cursor Without Tech Debt
URL: https://madebyaris.com/blog/cursor-ai-workflow-for-production
Published: 2026-08-13. Updated: 2026-09-24.
Cursor can make you look like a hero on Monday and a liability by Friday.
I’ve watched senior teams ship three features in a week with it. I’ve also watched the same teams spend the next two weeks cleaning up half-baked helpers, mystery config, and PRs nobody wants to review. Speed is easy. Speed that still looks like your codebase a month later? That’s the hard part.
I’m Aris Setiawan – senior full-stack for 13+ years, first Cursor Ambassador in Indonesia, and a MiniMax Dev Community Expert. I use Cursor on client work every week. I also mentor developers through Level up on how to use Cursor AI without turning the repo into a junk drawer.
This isn’t a feature tour. It’s the Cursor AI workflow I actually run when the code has to ship, get reviewed, and stay maintainable.
### The real problem: AI makes you fast and messy
Most “AI coding” advice stops at “prompt better.” That’s incomplete.
The failure mode I see most often isn’t a bad model. It’s a weak process:
- You ask for a feature. Cursor drafts half the app.
- You skim. Tests are green-ish. You merge.
- Two weeks later nobody knows why that new utility exists, why auth was touched, or why the same fetch logic now lives in three files.
That’s not a Cursor problem. That’s an ai coding workflow problem. The tool accelerates whatever habits you already have. Clear habits get clearer. Sloppy habits get expensive.
If you’ve felt that tension – “we’re shipping faster, but reviews hurt more” – this post is for you. Same goal if you’re evaluating Cursor for a team or cleaning up your own day-to-day: ship production code without wrecking the codebase.
For the debt angle in more detail (I wrote it in Bahasa first), see Technical debt on AI-built apps.
### What a good Cursor workflow actually optimizes for
A useful Cursor for developers setup doesn’t optimize for “lines generated.” It optimizes for three things at once:
- Speed – less time stuck on boilerplate and glue.
- Reviewability – a teammate can understand the diff in one sitting.
- Maintainability – the change still makes sense in six months.
If you only chase #1, you get demos. If you also protect #2 and #3, you get production.
That tradeoff shapes every step below. I’ll happily spend ten extra minutes scoping a change if it saves an hour of cleanup later. That’s the whole game.
### My default workflow: plan → scope → generate → review → test → commit
Here’s the Cursor AI workflow I default to on real client code. It’s boring on purpose. Boring ships.
#### 1. Plan in plain language (before you open Composer)
I write a short plan in chat or a scratch note:
- What user-facing behavior changes?
- Which folders am I allowed to touch?
- What must not change (auth, billing, migrations, public API)?
- How will I know it worked (tests, manual checks)?
Example:
Add CSV export on the invoices list. Touch only app/invoices and the existing export helper. Don’t change payment webhooks. Acceptance: unit test for CSV rows + manual download on staging.
If I can’t write that in five sentences, I’m not ready to generate code. Cursor is great at filling gaps. It’s terrible at reading your mind about product constraints.
#### 2. Scope the change on purpose
I open the relevant files myself. I @ the paths I care about. I don’t dump the whole monorepo into context “just in case.”
Why? Broad context invites broad diffs. Narrow context invites local, reviewable patches.
Rules of thumb:
- Prefer one vertical slice over a repo-wide “improve everything.”
- If the task needs a shared utility, say so. Don’t let the agent invent a parallel one.
- Call out files that are off-limits. Explicit “don’t edit X” saves painful reverts.
#### 3. Generate in small passes
I use agent/Composer for implementation, but I keep the blast radius small:
- Pass A: types + function signatures + failing test (or a clear checklist).
- Pass B: implementation to make the test pass.
- Pass C: wire-up (UI, route, job) only after the core logic is solid.
Big one-shot prompts feel productive. They also produce the PRs that make reviewers sigh. Small passes keep you in control.
When I ask for code, I ask for constraints, not vibes:
- Match existing patterns in nearby modules.
- Reuse helpers; don’t create utils2.ts.
- No drive-by refactors.
- Prefer boring, explicit code over clever abstractions.
#### 4. Review like the AI is a fast junior
This is non-negotiable. I treat every AI diff as untrusted until I’ve read it.
My review checklist:
- Does this change match the plan – and only the plan?
- Any new dependencies I didn’t ask for?
- Duplicated logic that already exists in the repo?
- Error handling consistent with our style?
- Secrets, env vars, or logging that shouldn’t ship?
- Naming that matches the domain language we already use?
I read the diff file by file. I don’t approve everything because the summary sounded confident. Confidence is cheap. Correctness is not.
#### 5. Tests and a real run
Unit tests if the logic matters. Integration smoke if the path crosses services. And I still click through the happy path myself.
AI is good at writing tests that assert what it already wrote. That’s useful, but incomplete. I add at least one case that would fail if the behavior were wrong – empty input, permission denied, weird timezone, the thing that bit us last quarter.
#### 6. Commit with a human message
Commit messages still matter. I write them as if Cursor wasn’t involved:
Add CSV export for invoices list with row-level tests.
Not:
Updated files via AI assistant for export feature improvements.
Your future self (and your teammates) will thank you.
### Rules and project context that prevent dumb diffs
Cursor gets smarter when the project has opinions. I keep a small set of rules and project notes that act like guardrails – not a novel.
What I put in them (keep it short):
- Stack and package manager noted in project rules.
- Stack note: Next.js with Vitest.
- Folder conventions under src/features.
- Prefer existing UI primitives.
- Focused unit tests for new modules.
- Ask before risky schema work.
I also lean on codebase context when I’m unsure where something lives. Pointing Cursor at the right module beats a long prompt that guesses architecture.
If the project has docs, I pull those in when the task touches that area. Not every prompt needs the whole wiki. Auth, billing, and data models usually do.
Good rules don’t make Cursor brilliant. They stop it from being randomly creative in the wrong places.
### How I use chat vs agent/Composer differently
People ask me for a Cursor AI tutorial that maps tools to jobs. Here’s the simple split I use.
#### Chat – thinking partner
I use chat when I need:
- Architecture options (job vs request-time export?)
- Debugging help with a stack trace and two suspect files
- Explaining an unfamiliar module before I touch it
- Reviewing a plan before I generate code
Chat is for decisions. I want tradeoffs, not a huge patch yet.
#### Agent / Composer – implementation muscle
I use agent/Composer when:
- The plan is clear
- The file set is scoped
- I want an actual diff I can read and test
Agent mode is for execution. I still stay in the loop. If it wanders into unrelated files, I stop it, tighten the prompt, and restart from a cleaner scope.
A pattern that works well:
- Chat: agree on approach.
- Agent: implement the smallest slice.
- Chat: review the riskiest bits.
- Agent: apply the fix only to those bits.
That’s an AI coding workflow, not a magic button.
### Team habits: what we accept (and reject) from AI
Solo habits don’t scale. Team habits do.
What I push teams toward:
- PR size caps. If the AI-generated PR is huge, split it. Reviewers shouldn’t need a weekend.
- Explain the non-obvious. Comment in the PR why a weird approach was chosen – especially if Cursor suggested it.
- No silent refactors. Formatting-only or “while I was here” cleanups belong in a separate PR.
- Own the code. The author is responsible for every line, AI or not. “Cursor wrote it” is not a defense in prod.
- Shared rules. Put conventions in the repo so everyone gets the same guardrails.
What we reject even if tests pass:
- New abstractions with one caller
- Copy-pasted modules that already exist under a different name
- Broad dependency upgrades bundled into a feature PR
- Auth or payment changes without a second human pair of eyes
If your team is adopting Cursor, align on this before you celebrate velocity metrics. Velocity without review standards is just faster debt.
Curious about plans and usage costs while you roll this out? Related reading (Bahasa): Cursor IDE pricing notes.
### When mentoring helps vs when you should hire Build
Not every team needs the same thing.
#### Choose mentoring / Level up when…
- Your developers already ship, but AI output is noisy
- You want a shared Cursor AI workflow across the team
- People are stuck in “prompt, paste, hope”
- Leads want review habits that survive after the coach leaves
That’s what Level up (Vibe Code Friend) is for: tutoring, pairing, and practical guardrails on your codebase – not toy demos.
#### Choose Build when…
- You need a product or feature delivered end-to-end
- Timeline matters more than teaching the team right now
- You want AI-assisted delivery with a senior owning architecture and quality
That is the AI development path – and the broader services hub if you’re still sorting Build vs Level up.
Honest take: mentoring compounds. Build unblocks. Plenty of clients do Build first, then Level up so the team can maintain what shipped. Either order is fine. Mixing them without a clear goal is not.
More about me and how I work with remote teams: About.
### Mistakes I see (and made)
I’ll keep this blunt.
1. Prompting for the whole feature in one go.
You get a tour-de-force diff. Nobody reviews it properly. Bugs hide in the middle.
2. Letting Cursor invent architecture mid-task.
If the repo already has a pattern, enforce it. New patterns need a decision, not a surprise.
3. Skipping the human plan.
“Make checkout better” is not a task. It’s a wish.
4. Trusting green tests from AI-written tests alone.
Tests that only mirror the implementation will nod along while production burns.
5. No off-limits list.
Without boundaries, agents helpfully rewrite shared packages.
6. Measuring success only by commits per day.
I care about time-to-merge and time-to-revert. If reverts go up, your workflow is lying to you.
I’ve made versions of all of these. The fix was never “use a smarter model.” It was a tighter loop: plan, scope, generate, review, test, commit.
### A short example of the loop in practice
Say I need a rate limit on a public API route.
- Plan: Redis-backed limiter, 60 req/min per IP, 429 with existing error shape. Touch only the public API routes and the shared middleware helper.
- Scope: Open the route file and existing middleware. Tell Cursor those are the only targets.
- Generate: Ask for the helper, wiring, and a unit test for the 429 path. Explicitly reuse the existing Redis client if one is already in the repo.
- Review: Check key naming, fail-open vs fail-closed, and whether local/dev is exempt.
- Test: Unit test plus hit the route with a quick script.
- Commit: One focused commit. PR description lists the fail mode we chose.
That’s how to use Cursor AI on production work without drama. The tool did the typing. I owned the decisions.
### Closing: ship faster, keep the codebase boring
Cursor is a force multiplier. Force multipliers don’t invent taste. You do.
If you want a practical path:
- Write a five-sentence plan.
- Scope files on purpose.
- Generate in small passes.
- Review like a skeptical senior.
- Prove it with tests and a real click-through.
- Commit like a human who cares about the next reader.
Do that consistently and your Cursor AI workflow starts compounding – fewer messy PRs, faster reviews, less AI-shaped debt.
If you want help installing these habits on your team, that’s exactly what Level up is for. If you need the feature built with a senior in the loop, look at AI development / Build or the full services page.
Ship fast. Keep the codebase something you’re willing to maintain on a Monday morning.
—
---
## Technical Debt pada Aplikasi buatan AI
URL: https://madebyaris.com/blog/technical-debt-pada-aplikasi-buatan-ai
Published: 2026-03-16. Updated: 2026-10-24.
AI sekarang bisa membuat aplikasi dengan cepat — tinggal ketik prompt, langsung jadi. Tapi, ada harganya. Karena kecepatan itu, ada beberapa hal yang sering terlewat: duplikasi function, query yang seharusnya penting tapi diabaikan, dan pemilihan teknologi yang kurang tepat.
Nah, inilah yang disebut technical debt — biaya tersembunyi dari pengembangan yang terlalu cepat.
Kalau aplikasi buatan AI lo perlu dirapikan sebelum masuk production, lihat layanan AI development (halaman berbahasa Inggris).
JENIS TECHNICAL debt YANG SERING DIHASILKAN AI:
1. Fungsi Duplikat — AI kadang buat function baru padahal sudah ada yang sama. Kode numpuk, maintenance jadi ribet.
2. Masalah N+1 — Ini yang paling berbahaya. AI sering lupa optimize query, akhirnya aplikasi jadi lemot saat data banyak.
3. Kode Tidak Efisien — Ada yang jelek, ada yang overkill. Kedua-duanya menurunkan performa.
4. Strategi Cache yang Salah — Justru bikin bingung antara user dan developer.
5. Teknologi Tidak Sesuai — AI kadang saranin tool yang nggak tepat untuk use case lo.
6. Tidak Ada Dokumentasi — Termasuk komentar! Kode canggih tapi nggak ada yang mengerti.
TECHNICAL DEBT BUKAN SKILL ISSUE
Banyak orang pikir semua ini karena user nggak bisa pake AI. Nope. Masalahnya bukan di skill — tapi di expectation dan pemahaman tools.
Tiap tool punya target user-nya masing-masing. Cursor IDE? Bagus banget buat developer yang sudah mengerti coding. Tapi buat user yang nggak punya basic development? Bakal overwhelm. Terlalu banyak opsi, terlalu banyak hal yang harus dipahami.
Jadi, sebelum pilih tool AI, pastikan tool itu sesuai dengan kemampuan lo. Jangan memaksakan developer tool ke orang yang cuma mau bikin website sederhana.
ALTERNATIF UNTUK NON-DEVELOPER
Ada beberapa alternatif yang lebih ramah untuk orang tanpa basic coding:
1. No-code builders — Bubble, Webflow, atau WordPress page builders. Lebih terbatas, tapi hasilnya lebih stabil.
2. AI-powered website builders — Wix ADI, Squarespace AI. Masih ada limits, tapi jauh lebih user-friendly.
3. Hybrid approach — AI generate basic structure, developer polish. Ini yang ideal untuk project yang butuh customisasi.
Tetap saja, semua alternatif di atas tetap ada technical debt-nya. Bedanya, untuk no-code dan page builders, technical debt-nya lebih ke arah customization yang terbatas dan dependensi ke platform tertentu.
GIMANA CARA MENGURANGINYA?
Kabar buruknya: technical debt dari AI hampir tidak bisa dihindari sepenuhnya. Tapi kabar baiknya, bisa diminimalisir:
1. Review kode sebelum deploy — Jangan langsung publish. Cek sendiri atau minta developer lain lihat.
2. Gunakan AI untuk skeleton, bukan final product — Biar struktur jadi, lo yang refine.
3. Test performance — Jangan cuma tes fitur. Load test, stress test, baru deploy.
4. Audit berkala — Cek kode minimal sebulan sekali. Refactor yang perlu, hapus yang nggak dipakai.
PENUTUP
AI adalah tools yang powerful, tapi bukan magic wand. Hasil yang dihasilkan masih butuh sentuhan manusia untuk jadi produk yang solid. Jangan bergantung 100% ke AI — combine dengan expertise lo sendiri.
Technical debt itu seperti utang — bisa dibayar, tapi kalau terus numpuk, bakalan bangkrut juga.
---
## Death of (past) Me, and my rebirth in 2026
URL: https://madebyaris.com/blog/death-of-past-me-and-my-rebirth-in-2026
Published: 2025-12-25. Updated: 2026-09-24.
Some folks might be know why I didn’t show up on every community event for about 3 years.
Well, on that year, I’m fighting with myself, and conquer my trauma. This is not the thing that can be resolve overnight.
So, I’m more focus on work and work.
Until, I found someone who opened my heart again. she’s not perfect, but, I wanted to spend more time with her. Maybe like 50-80 years, that’s what I ask to My God.
And I pretty much stable on My Work, until the AI coming from 2024, and I noticed what you might not notice about it.
I took the chance and use the power AI to step-up my Programming! This help me to be more efficient and can focus what I wanted more.
More time to learn, more time to networking, and more time to enjoy life
And for the 2026, I pray to My God so I can change my status from single man to family man 💍.
My schedule on this year is:
- Do more good thing.
- Be close to God.
- Change the status of my single.
- Work as Community leader for 5-10 years.
- Building Agency web at Malang, East Java
- leveling up to IDR 1-2 Billion per year income.
- Be more healthier.
- building and attend many community in SEA
- Create a Visa to EU
I pray that 2026 will be the year of my rise and my love.
And I hope that too to everyone.
Happy New Year for everyone!
---
## Tentang skema harga Cursor IDE
URL: https://madebyaris.com/blog/tentang-skema-harga-cursor-ide
Published: 2025-07-04. Updated: 2026-10-24.
Mungkin teman-teman sudah mengetahui tentang Skema Unlimited baru dari cursor.com, yang mana sekarang sudah enggak ada lagi tuh yang namanya slow-request 😀
Lalu apa yang membedakan Skema lama dengan Skema baru? Dan kenapa Skema terbaru ini cukup fair.
### Tentang Skema Harga Terbaru
Untuk harga biaya Cursor sendiri ada penambahan, yakni sekarang ada plan Pro, Pro+, dan Ultra.
Bisa dilihat dari gambar diatas bahwa sudah tidak ada lagi fast dan slow request, semuahnya menjadi fast request dan unlimited.
Yang mana ini sangat menguntungkan banget bagi kita pengguna Pro plan, karena kita bisa call agent secara terus-terusan tanpa batasan.
Dan juga Sekarang kita bisa menggunakan MAX Mode tanpa perlu membayar, karena sekarang MAX Mode sudah termasuk pada Pro plan, terus hitunganya juga per-request.
### Apa perbedaan dengan skema lama?
Perbedaan paling mencolok adalah skema baru semuanya fast request, sedangkan skema lama itu mereka memiliki fast request sampai 500, dan setelah itu bakal menggunakan slow request.
Eh bukanya berarti sama-sama unlimited? Ya benar, keduanya sama-sama unlimited, yang membuat skema lama kurang menarik adalah semakin sering kita menggunakan slow request, semakain lama kita bakal menunggu, karena ini sendiri bisa Saya konfirmasi.
Skema terbaru sekarang limitnya adalah rate-limit, yang artinya penguna akan dibatasi prompt oleh penggunaan dan retensi waktu.
### UPDATE: perubahan skema berdasarkan compute
Pada saat penulis meneruskan artikel ini (4 Juli 2025, penulis mendapat info bahwa untuk penggunaan terbaru sekarang menggunakan compute base, yang artinya menurut penulis, compute ini bisa berarti dihitung per-penggunaan cpu, bisa jadi utilitasi cpu ataupun total penggunaan waktu cpu.
https://forum.cursor.com/t/clarifying-june-16-pro-changes/111740
Apakah ini bakal bikin user lebih banyak penggunaan prompt? Jawabanya untuk saat ini, Saya tidak tahu dikarenakan perubahanya dilakukan ketika roll-over request Saya belum dilakukan, gampangnya roll-over = reset request.
Yang artinya usage kita jadi $0 dan kita tidak ter-limit lagi, nah untuk memahami apakah plan terbaru saat ini bakal “baik untuk kita”, maka Saya menunggu tanggal 8 Juli, dimana itu adalah waktu “seharusnya” akun Pro saya terkena reset request.
### Kenapa Pricing plan mereka sekarang bukan unlimited?
Sekarang kalau teman-teman melihat langsung harga di cursor.com, kata-jata unlimited agent diubah menjadi Extended limits on agent.
Apakah ini tanda yang buruk? Enggak juga, kalau teman-teman terbiasa beli API LLM dari Claude OpenAI dan lainya, teman-teman pasti sadar bahwa harga mereka itu cukup-cukup mahal.
Dan Cursor itu bisa memberikan kita sampai $700 API price request, dari yang kita cuma bayar $20. yang artinya cursor sedekah API sebanyak $680 ke teman-teman.
Dari sini kita bisa melihat bahwa cursor, menurut Saya sedang mencari sebuah sweet-position antara mencari untung dengan memberikan yang terbaik untuk para usernya.
### Kedepanya bakal bagaimana?
Untuk pricing ini, Saya belum tahu bakal seperti apa sampai Saya bisa melakukan testing ulang pada tanggal 8 Juli besok.
Kalau tim teman-teman ingin mulai memakai Cursor dengan project rules dan cara review yang jelas, lihat mentoring Cursor untuk tim.
Yang pasti, Saya percaya cursor akan memberikan yang terbaik untuk pelangganya, dan selain itu bakal ada banyak fitur di Cursor kedepanya.
Apa aja? Ditunggu aja announcement secara officialnya ya 😀
---
## Tentang Next.js dan PHP
URL: https://madebyaris.com/blog/tentang-next-js-dan-php
Published: 2025-03-13. Updated: 2026-10-24.
Dari 6 bulan lalu Saya mempelajari ulang tentang Node.js, React, dan juga Next.js. Saya mempelajari bagaimana cara membuat website dengan teknologi Javascript dan terakhir sampai membuat Dashboard dengan fitur CRUD dan juga SEO.
Ada sekitar 4-5 project Next.js yang Saya handle pada 6 bulan ini, dan rata-rata tidak jauh dari implementasi animasi, CRUD, dan juga SEO. Untuk project ini sendiri adalah real-life project yang diberikan oleh salah satu client yang sudah bekerjasama dari tahun 2017.
```
By the way ini adalah tulisan yang saya buat sekitar januari 2024, dan baru Saya lanjutkan plus publish pada Maret 2025.
```
Saya mempelajari Next.js sendiri untuk berpindah karir dari WordPress developer menjadi Next.Js Developer. Tapi walau begitu 90% project dan kerjaan kantor masih WordPress semua 😅.
### Kenapa Next.js?
Sebelum Saya bahas, untuk teman-teman yang ingin mengatahui apa itu Next.js bisa cek disini apa itu next.js
Alasan utama karena Saya ingin naik level dalam hal development dan juga untuk tetap relevant dengan dunia industri saat ini. Apalagi dengan pamor Next.js yang masih tinggi, Saya yakin masa depanya cukup bagus banget. Apalagi dengan kita mempelajari React, kita dapat switch ke framework-react yang lain lebih cepat.
Alasan kedua tentu karena ada kesempatan untuk mengerjakan project React-based.
End-goal Saya sendiri adalah memanfaatkan Next.js dalam membuat aplikasi yang memiliki kompleksitas dan juga pengolahan data yang besar.
Selain itu, dalam benchmark yang Saya lakukan, dalam urusan proses node/javascript dapat handle lebih banyak daripada PHP yang IO blocking.
### Apakah mudah belajar Next.js?
Untuk Saya, perlu waktu 4 bulan untuk mempelajari react, node, dan Next.js sampai bisa Saya bilang “cukup” mudah untuk mempelajari next.js ini.
Secara dokumentasi sangat mudah dimengerti, dan sudah banyak tutorial gratis di Internet cara membuat website dengan next.js dari 0 sampai jadi.
Tapi, bukan berarti Next.js ini sempurna ya, karena tidak semua fitur yang Saya butuhkan disiapkan oleh mereka.
Salah satu contohnya adalah kita perlu membuat Dashboard sendiri, API sendiri, bahkan sampai CRUD operation pun juga perlu dibuat sendiri secara manual.
Berbeda dengan saat kita menggunakan Framework di PHP seperti Laravel dan sebagainya hehe.
### Proyeksi Next.js di 2025
Sebenarnya, banyak banget kompetitor baru untuk Next.js ini, salah satu contohnya adalah Remix Js, Nuxt, Tan Stack, dan juga beberapa tech stack berbasis Javascript/Typescript lainya.
Tetapi, Hampir semua diatas itu berbasis Open source, tapi sedikit berbeda dengan Next.js, selain basisnya adalah open source, Next.js juga dibacking oleh perusahaan hosting Vercel.
Kita perlu tahu bahwa Commercial Open Source (COSS) lebih bertahan lama dibanding project OSS, tentunya ini sangat subjective sekali, Saya sendiri-pun melihat bagaimana beberapa project open source yang sudah tidak lagi di-maintenance oleh owner karena masalah finansial.
Berbeda dengan COSS yang memiliki backing teta, project seperti ini bisa bertahan lama karena ada backer yang konstan selalu maintenance dan memberi perhatian khusus, contohnya Autommatic memiliki layanan hosting dan VIP agency hosting.
Mereka dapat membiayai project WordPress org, secara cuma-cuma.
### Indonesia Melek Teknologi Baru
Saya sendiri melihat sudah ada banyak website pemerintah, pemprove, dan juga beberapa website lokal yang menggunakan Next.js.
Kalau teman-teman ingin website bisnis dengan Next.js, cara saya mengerjakannya ada di halaman Next.js developer Indonesia.
Dengan perkembangan yang sangat pesat saat ini, kita dapat memastikan bahwa pekerjaan untuk Next.js ini terhitung masih “panas”.
Mungkin dengan adanya perkembangan teknologi baru seperti WASM, Meta-framework baru, yang bakal bikin Next.js tersingkir. Tentunya bakal lama banget itu mah.
---
## Next.js Pada VPS Murah
URL: https://madebyaris.com/blog/next-js-pada-vps-murah
Published: 2025-03-12. Updated: 2026-10-24.
Apakah teman-teman pernah ingin melakukan deploy Next.js pada VPS tapi takut resourcenya terlalu besar? Atau khawatir Nextjs membutuhkan Spesifikasi CPU dan RAM yang besar?
Untuk menjawab pertanyaan diatas, kita akan mengupas tuntas tentang bagaimana cara melakukan deployment Next.js pada VPS yang paling murah.
VPS yang Saya gunakan ini memiliki spesifikasi sebagai berikut:
```
Lokasi : Indonesia
OS: Ubuntu 24.04
CPU: 1 vCPU
RAM: 1 GB
Web Server: Nginx 1.27 (Sudah dioptimasi)
Nodejs: 22.14.0
Next.js: 15.2 (Experiment: useCache, OptimizedCss)
PM2
Blog: https://gosite.id/
```
Dari spesifikasi diatas, kecil banget kan 🤯! Lalu kata orang-orang yang menyebutkan bahwa Next.js itu butuh resource gede bagaimana? Selama ini Saya juga sering mendengar akan hal ini, tapi Saya sendiri belum pernah mengalaminya (selain pada level development). Mungkin Mereka skill-issue.
Atau bisa jadi sekala project mereka sudah besar, but who knows, selama kita tidak terlibat dalam project dan melihat struktur dan enviropment, kita tidak tahu ada apa aja didalamnya.
### Proses pembuatan Next.js
Dalam proses pembuatan aplikasi Next.js, Saya copy langsung dari madebyaris.com dan melakukan redesain website yang mirip dengan website gosite.id.
Diatas adalah website dari sponsor kita untuk research dan pembuatan artikel kita ini.
### Hasil pembuatan website Next.js
Untuk hasil dari redesain website sendiri dapat dilihat dibawah sini:
https://gosite-madebyaris-com.vercel.app
https://github.com/madebyaris/gosite.madebyaris.com
Gratis dipakai oleh teman-teman, yang penting copyright jangan dihapus ya 😀!
Untuk kodingan dan bagaimana cara deployment mungkin akan kita bahas pada artikel kedepan, untuk saat ini kita akan berfokus bagaimana performa dari Nextjs di VPS murah.
### Waktu Proses build
Untuk proses build sekitar 20 detik, dengan total halaman sekitar 38, dan kita juga menggunakan SSR + ISR untuk blognya.
### Google Score Pagespeed
Saat ini, skor dari pagespeed sangat penting (selain performa), karena dengan skor yang sempurna, website kita akan lebih disukai oleh Google. Untuk skor sendiri seperti dibawah ini:
### Pengunaan RAM dan CPU
Sekarang kita akan membahas tentang pengunaan / resource RAM dan CPU; Apakah berat? Oh tentu ini sangat objective sekali. Jadi ini tergantung dari kodingan Next.js teman-teman sendiri ya.
#### Pengunaan RAM
Untuk pengunaan RAM sendiri sangat kecil sekali, dari pengunaan saat proses Load test sendiri terhitung sangat kecil sekali:
Pengunaan sekitar 15% dari 1GB atau sekitar 150MB , hitunganya ini cukup kecil sekali, apalagi sifat dari aplikasi NodeJS + Next.js yang termasuk single-thread, sehingga dia tidak akan melakukan spwan ketika banyak request, jadi walau ada 10rb request secara bersamaan, maka pengunaan RAM gak bakal naik signifikan.
#### Penggunaan CPU
Kalau RAM begitu kecil, lalu bagaimana dengan pengunaan CPU? Berbeda dengan pengunaan RAM yang cukup statis, pengunaan CPU pada Next.js cukup tinggi ketika dilakukan stress-test, ini bisa terjadi karena proses dari single-thread membebani pengunaan CPU, semakin banyak request, semakin besar pengunaan CPU.
Lalu apakah ada solusi dalam mengurangi pengunaan CPU? Kalau mengurangi sepertinya sulit, tapi kita bisa membuat pengunaan CPU menjadi multi-thread sehingga tidak terkena bottleneck karena hanya memggunakan satu thread/CPU saja.
Tapi kita tidak melakukan multiple-thread karena kita ingin berfokus pada “vanilla” performance, sehingga kita dapat melihat dari kecepatan/performa dari sebuah web Next.js
### Proses Stress Test
Proses stess test sendiri kita lakukan dengan loader.io, agar lebih comperhensive dan sesuai dengan kejadian di dunia nyata, bukan hanya test performa API “hello world” 🗿 yang banyak di-share pada website-website.
Yang pertama kita lakukan Stress test dengan 200 request per detik (1 request = 1 website load full), hasilnya tidak ada error sama sekali, dan rata-rata response time adalah 363ms.
Ini kalau kita compare dengan website WordPress tanpa optimasi, hanya bisa handle sekitar 50-100 request per detik Saja.
Lalu, Saya ingin mencoba untuk melakukan testing dari 0 – 1200 request per detik:
Dari sini kelihatan ternyata kita hanya bisa menproses request sebanyak 500 request per detik, diatas itu bakal sering error 500 dan Network.
Nah sebelum itu mari kita bahas perbedaan error 500 dan Network:
Error 500 indikasi terjadi karena aplikasi tidak kuat handle request, tapi ini bisa juga indikasi bahwa web server yang kita gunakan sudah mencapai limit.
Error Network itu bisa lebih ke arah infrastruktur internet dari VPS tidak bisa handle proses yang berlebih.
Disini, saya ingin agar tidak terkena bottleneck Error 500, jadi Saya sedikit optimasi Web server (Nginx) agar bisa handle thread lebih dari 700 request dan juga bisa handle multi-request.
Setelah optimasi, sekarang Next.js dapat handle sekitar 600 request per detik tanpa ada error sama sekali.
Dan waktu saya lakukan stress test lagi dengan 0 – 1000 request per detik
Kita dapat handle 90rb lebih request dalam satu menit.
Bisa dilihat network sudah 0 dan juga error 500 juga sudah turun.
### BONUS optimasi
Untuk optimasi terakhir, Saya sedikit melakukan “cheat” dengan menggunakan cache Nginx (Yes benar, diatas itu tanpa nginx cache sama sekali):
Disini terlihat bahwa Next.js web sekarang dapat handle 1280 request per detik, kalau kita hitung 24 jam, maka bisa handle 110jt request, wow menarik banget ya.
Kalau teman-teman butuh bantuan memasang Next.js di VPS sendiri, lihat halaman jasa Next.js Indonesia.
### Terima kasih Sponsor kita Gosite.id
Terima kasih untuk sponsor kita, yakni Gosite.id , dan ownernya Mas Adi Putra, telah meminjamkan VPSnya untuk dilakukan server testing 🫡.
```
Gosite.id adalah layanan jasa optimasi WordPress
terkemuka di Indonesia,
fokus pada peningkatan kecepatan situs web. Gosite.id menawarkan solusi optimasi speed WordPress,
setup VPS, migrasi WordPress.
Dengan harga terjangkau, Gosite.ID membantu bisnis meningkatkan performa website.
```
### Kesimpulan
Untuk kesimpulan akhir, Next.js dapat digunakan pada VPS murah dengan spesifikasi 1vCPU dan 1GB RAM, dan performanya juga sangat bagus sekali.
Selama kita paham bagaimana cara melakukan optimasi website dan server, kita dapat meng-utilisasi performa sampai mentok.
Tapi, memang perlu dipahami bahwa untuk pengunaan seperti Web E-Commerce dan Dashboard app yang memiliki background service banyak tidak cocok untuk menggunakan VPS dengan spek yang rendah.
Jadi, ini cocok untuk Next.js dengan website ber-tipe Company Profile, Listing, Blog dengan ribuan user.
---
## Switch to headless WordPress for better experience
URL: https://madebyaris.com/blog/switch-to-headless-wordpress-for-better-experience
Published: 2025-02-22. Updated: 2025-02-25.
It’s already 2025, happy new year everyone 🥳. I know that it’s too late to say that, but hey! At least I say that, lol.
If you are a long-time reader, you might have noticed that my Website looks so different from the last time you saw it. Yes, I’ve changed my design to look cleaner and simple.
Not only that, I also switched from full WordPress to Next.js + Headless WordPress; why do I do that?
Okay, I will break down some of the questions and explain why you should switch to.
### Performance of Next.js
This might not surprise you, and you may notice that this Website doesn’t load as much as it used to. Well, it is because I switched to an awesome Front-end Framework named Next.js.
This is a no-brainer for me to switch from bloated front-end WordPress to Next.js.
You can do that too on WordPress, but I noticed there are some aspects you can’t do on PHP. This is one of the reasons I switched my stack from “heavy” WordPress to Next.js.
### More Secure than Traditional WordPress
We can argue about it, but let’s be clear here: this is one of the most convinced me to switch from traditional WordPress to Headless WordPress + next.js as front-end.
You have no idea how many attacks I receive from an attacker in one day; it is enough for me to review their intention from my “little” and low-rank Website 🥹.
But, from my experience, most of them are just doing it for fun, or if they are serious, they’ll make your WordPress site their robot to attack the server or someone else computer.
I’m not joking; I’ve done that once on my own site, and it convinced me to learn cybersecurity on a level server, tho.
### Ready to take millions request
I switched from VPS to Edge server; why do I do that? Of course, my site can serve you faster, and I want to handle a million requests simultaneously (Please don’t do that; I can only serve 20 Million user requests at best).
While my site can do that, my monthly plan must be upgraded then 😄.
But, as long as my site only handles 10-15 million users per month, it’s still a beast.
And, If shortly I do advertising, at least my site won’t be broken like yours, lol 😙.
### WordPress headless is the future
This may sound absurd, but I believe that WordPress should be treated as a CMS, no more and no less.
This will keep the performance, and the security is more secure than we have a lot of plugins installed in one place 😌.
However, as long as you follow the best practices and enhance the security, it “should” keep your site away from the attacker.
### Are you ready to switch?
Not everything is fit for Your needs, but if you are ready to take your Website to the next level for:
- You need more control of your Website.
- Need a website that can handle millions of requests.
- Want a more secure WordPress site?
Then, it’s time for you to switch from traditional WordPress to Headless WordPress + Next.js! If you don’t have an IT to help You, I can help you to upgrade it 😎.
---
## Which OS is the Best for VPS?
URL: https://madebyaris.com/blog/which-os-is-the-best-for-vps
Published: 2023-10-13. Updated: 2026-10-19.
Virtual Private Servers (VPS) have become a popular hosting solution for businesses and individuals looking for a reliable and cost-effective hosting option. One crucial decision to make when setting up a VPS is choosing the right operating system (OS). In this article, we will explore the options available and help you determine which OS is the best for your VPS.
### What is a VPS?
Before diving into the world of VPS operating systems, let’s briefly define what a VPS is. A VPS is a virtualized server that exists within a physical server. It offers users more control and flexibility compared to shared hosting. With a VPS, you can choose your operating system, install custom software, and have dedicated resources.
### Importance of Choosing the Right OS for a VPS
Selecting the right OS is a critical decision because it can greatly impact the performance and functionality of your VPS. The OS serves as the foundation for all the software and applications you run on your server. It determines how your server interacts with hardware, handles security, and manages resources.
### Popular Operating Systems for VPS
#### Linux-based OS
Linux-based operating systems, such as Ubuntu, CentOS, and Debian, are among the most popular choices for VPS. They are known for their stability, security, and the vast array of software and tools available for free. Linux-based OSs are preferred by many web developers and system administrators for their flexibility.
#### Windows Server
Windows Server is another popular choice, especially for those who need to run Windows-specific applications. It offers a user-friendly interface and compatibility with Microsoft technologies. However, it tends to be more resource-intensive compared to Linux, and licensing costs can be higher.
#### FreeBSD
FreeBSD is an open-source Unix-like operating system known for its exceptional performance and security. It’s a great choice for advanced users and those who want to host websites and applications with high demands. However, it may not be as user-friendly as Linux or Windows for beginners.
#### CentOS
CentOS is a free, community-supported version of Red Hat Enterprise Linux. It’s known for its stability and security features. CentOS is a great choice for those who want a Linux-based OS with enterprise-level support.
### Factors to Consider When Choosing an OS
#### Performance
Consider the performance requirements of your applications. Linux-based OSs are known for their performance, while Windows Server is suitable for specific Windows applications. FreeBSD is excellent for high-performance needs.
#### Compatibility
Check the compatibility of your chosen OS with the software and applications you intend to run on your VPS. Ensure that your OS supports your requirements.
#### Security
Security is a top priority. Linux-based OSs and FreeBSD are known for their robust security features. Windows Server is secure but may require additional configurations.
#### Cost
Evaluate your budget. Linux-based OSs are generally free, while Windows Server comes with licensing costs. CentOS offers enterprise-level features without the associated costs.
### Pros and Cons of Linux-based OS
#### Pros
- Stability: Linux-based OSs are renowned for their stability, making them suitable for long-term projects.
- Security: Strong security features and regular updates.
- Cost-effective: Many Linux distributions are free to use.
- Open-source: A vast community and resources are available for support.
#### Cons
- Learning curve: Beginners may find it challenging to use.
- Limited Windows compatibility: If your applications are Windows-specific, Linux may not be ideal.
### Pros and Cons of Windows Server
#### Pros
- User-friendly: Windows Server has an intuitive interface.
- Compatibility: Perfect for Windows-specific applications.
- Support: Access to Microsoft support and resources.
#### Cons
- Resource-intensive: It can be demanding on your server’s resources.
- Licensing costs: Windows Server requires paid licenses.
### Pros and Cons of FreeBSD
#### Pros
- Exceptional performance: Ideal for resource-intensive applications.
- Security: Strong security features.
- Open-source: No licensing costs.
#### Cons
- Advanced user-oriented: Not the best choice for beginners.
- Limited software compatibility: May not support all applications.
### Pros and Cons of CentOS
#### Pros
- Stability: Offers enterprise-level stability.
- Security: Strong security features.
- Free: CentOS is free to use.
#### Cons
- Limited support: Community-based support may not be as robust as enterprise support.
- Not suitable for all applications: Some specialized applications may require other OSs.
### Making the Decision
Choosing the best OS for your VPS depends on your specific needs. Consider the factors discussed, such as performance, compatibility, security, and cost. Evaluate the pros and cons of each OS in relation to your requirements. It’s important to make an informed decision to ensure the success of your VPS hosting.
### Conclusion
In the world of VPS hosting, the choice of the operating system plays a pivotal role in your server’s performance and functionality. Each OS comes with its unique features, advantages, and disadvantages. Whether you opt for a Linux-based OS, Windows Server, FreeBSD, or CentOS, ensure that it aligns with your project’s goals and technical requirements.
---
## How to Pick VPS for WordPress
URL: https://madebyaris.com/blog/how-to-pick-vps-for-wordpress
Published: 2023-10-13. Updated: 2026-10-25.
In the world of web hosting, Virtual Private Servers (VPS) have become a popular choice for hosting WordPress websites. VPS hosting offers a balance between affordability and performance, making it an ideal solution for those looking to take their WordPress site to the next level. In this article, we will guide you through the process of selecting the right VPS for your WordPress site, ensuring that you get the best value for your investment.
### Table of Contents
- What is VPS Hosting?
- Why Do You Need VPS Hosting for WordPress?
- Assessing Your WordPress Hosting Needs
- Managed vs. Unmanaged VPS Hosting
- Finding the Right Hosting Provider
- Considerations for Server Location
- Examining Server Resources
- Understanding Scalability and Growth
- Security Measures for Your VPS
- Setting Up Your VPS for WordPress
- Optimizing Your WordPress Installation
- Monitoring and Maintenance
- Backups and Disaster Recovery
- FAQsWhat is the difference between shared hosting and VPS hosting for WordPress?
- Is managed VPS hosting worth the extra cost?
- Can I upgrade my VPS plan as my WordPress site grows?
- How can I improve the security of my WordPress site on a VPS?
- What backup strategy is recommended for a WordPress site on a VPS?
### What is VPS Hosting?
Before diving into the specifics of selecting a VPS for your WordPress site, let’s first understand what VPS hosting is. A VPS is a virtualized server that exists within a larger physical server. Unlike shared hosting, where multiple websites share the same server resources, VPS hosting allocates dedicated resources to your website. This means that your site’s performance is less affected by other websites, resulting in faster load times and better overall performance.
### Why Do You Need VPS Hosting for WordPress?
WordPress is a powerful and flexible platform, but as your website grows, so do its demands. Shared hosting might suffice for a small personal blog, but if your website receives higher traffic or you’re running an online business, VPS hosting becomes crucial. The dedicated resources and enhanced control offered by VPS hosting can significantly improve your WordPress site’s speed, reliability, and security.
### Assessing Your WordPress Hosting Needs
The first step in choosing the right VPS for your WordPress site is to assess your specific hosting needs. Consider factors like your website’s size, anticipated traffic, and technical requirements. Understanding your needs will help you determine the necessary server resources and features.
### Managed vs. Unmanaged VPS Hosting
You also need to decide whether you prefer managed or unmanaged VPS hosting. Managed VPS hosting comes with technical support and maintenance, making it an excellent choice for those who want to focus on their website’s content rather than server management. On the other hand, unmanaged VPS hosting offers more control but requires technical expertise for setup and maintenance.
### Finding the Right Hosting Provider
Choosing the right hosting provider is crucial. Look for providers with a strong reputation, good customer reviews, and a track record of reliable service. It’s also essential to compare pricing and features to ensure that you’re getting a competitive deal.
### Considerations for Server Location
The physical location of your VPS server can impact your website’s performance. Select a server location that is geographically close to your target audience to reduce latency and improve loading times.
### Examining Server Resources
Understanding the resources allocated to your VPS is vital. Check for the amount of RAM, CPU cores, and storage space offered by the hosting provider. Your server’s resources should match your website’s needs.
### Understanding Scalability and Growth
As your WordPress site grows, you’ll need the flexibility to scale your resources. Choose a VPS hosting plan that allows easy scalability, so you can adapt to changing traffic and demands.
### Security Measures for Your VPS
Security is paramount for any website. Ensure that your VPS hosting provider offers robust security measures, including firewalls, malware scanning, and regular updates to keep your WordPress site safe.
### Setting Up Your VPS for WordPress
Once you’ve selected a VPS and hosting provider, you’ll need to set up your server. This includes installing your preferred operating system and configuring it for WordPress. Many hosting providers offer one-click installations for WordPress, simplifying this process.
### Optimizing Your WordPress Installation
To get the best performance from your VPS, optimize your WordPress installation. This includes using caching plugins, image compression, and content delivery networks (CDNs) to improve loading times.
### Monitoring and Maintenance
Regular monitoring and maintenance are essential for the long-term health of your VPS and WordPress sites. Implement monitoring tools to track performance and address any issues promptly.
### Backups and Disaster Recovery
Don’t forget to set up regular backups and a disaster recovery plan. Accidents can happen, and having backups ensures that you can quickly restore your website in case of data loss.
### Conclusion
Choosing the right VPS for your WordPress website is a critical decision that can impact your site’s performance and success. By assessing your needs, selecting the right hosting provider, and optimizing your setup, you can ensure that your WordPress site runs smoothly and efficiently on a VPS.
Now, let’s answer some common questions about VPS hosting for WordPress:
### FAQs
#### What is the difference between shared hosting and VPS hosting for WordPress?
Shared hosting involves sharing server resources with other websites, which can affect performance. VPS hosting provides dedicated resources, enhancing your site’s speed and reliability.
#### Is managed VPS hosting worth the extra cost?
Managed VPS hosting is ideal for those who prefer a hassle-free experience. It includes technical support and maintenance, allowing you to focus on your website’s content.
#### Can I upgrade my VPS plan as my WordPress site grows?
Yes, most VPS hosting providers offer scalability options, allowing you to upgrade your resources as your website’s needs increase. But, it still depends on the VPS companies
#### How can I improve the security of my WordPress site on a VPS?
Enhance security by choosing a VPS hosting provider with robust security measures, regularly updating WordPress, and using security plugins.
#### What backup strategy is recommended for a WordPress site on a VPS?
It’s essential to set up regular automated backups and a disaster recovery plan to protect your website’s data in case of unexpected issues.
For monthly updates, backups and monitoring on your WordPress VPS, see WordPress maintenance services.