https://rocketeersapp.com/feed.xml<![CDATA[Rocketeers]]>All published articles from Rocketeers.2026-06-30T00:00:00+00:00<![CDATA[Enable JIT in PHP 8.x OPcache]]>https://rocketeersapp.com/php-8-opcache-jit2024-11-21T00:00:00+00:00<![CDATA[Detect Googlebot visits using nginx]]>https://rocketeersapp.com/detect-googlebot-nginx2024-11-18T00:00:00+00:00<![CDATA[Use nginx try_files to make your site static]]>https://rocketeersapp.com/nginx-try-files2024-11-18T00:00:00+00:00<![CDATA[Log bot requests in nginx]]>https://rocketeersapp.com/log-bot-requests-nginx2024-11-18T15:01:08+00:00<![CDATA[Improving PHP performance]]>https://rocketeersapp.com/php-performance2024-11-21T11:15:44+00:00<![CDATA[What is Cloudflare?]]>https://rocketeersapp.com/what-is-cloudflare2026-06-30T00:00:00+00:00<![CDATA[How to host your own website]]>https://rocketeersapp.com/how-to-host-your-own-website2026-06-30T00:00:00+00:00<![CDATA[Tools to validate your website]]>https://rocketeersapp.com/tools-to-validate-website2026-06-30T00:00:00+00:00<![CDATA[How to install multiple PHP versions on the same server]]>https://rocketeersapp.com/how-to-install-multiple-php-versions-on-same-server2026-06-30T00:00:00+00:00<![CDATA[How to install Certbot]]>https://rocketeersapp.com/how-to-install-certbot
/dev/null 2>&1' \
| sudo tee /etc/cron.d/certbot
```
Certbot only actually renews a certificate when it's within 30 days of expiry, so running daily is safe and gives you a wide margin if a renewal ever fails. We cover the renewal setup in more depth in [renew SSL certificates automatically](/renew-ssl-certificates-automatically).
## Confirm it's working
Check what Certbot is managing and when each certificate expires:
```bash
sudo certbot certificates
```
You can also verify the live certificate the way a browser sees it — see [how to check SSL certificate expiration](/check-ssl-certificate-expiration).
## Let Rocketeers handle it
Installing Certbot is the easy part. The work that never ends is the part around it: storing each provider's API credentials securely, picking the right challenge per domain, wiring the renewal hook into Nginx, and noticing when a renewal silently fails three months from now. Rocketeers provisions Certbot with every DNS plugin, issues certificates over HTTP or DNS automatically, and renews them in the background for every site on every server you run — so a certificate never lapses and you never think about it again.]]>
2026-06-30T00:00:00+00:00<![CDATA[How to install Nginx on Ubuntu]]>https://rocketeersapp.com/how-to-install-nginx2026-06-30T00:00:00+00:00<![CDATA[How to install Node.js on Ubuntu]]>https://rocketeersapp.com/how-to-install-nodejs2026-06-30T00:00:00+00:00<![CDATA[Website launch checklist]]>https://rocketeersapp.com/website-checklist2026-06-30T00:00:00+00:00<![CDATA[Why do you need Cloudflare?]]>https://rocketeersapp.com/why-do-you-need-cloudflare2026-06-30T00:00:00+00:00<![CDATA[How to install MySQL on Ubuntu]]>https://rocketeersapp.com/how-to-install-mysql2026-06-30T00:00:00+00:00<![CDATA[How to renew SSL certificates automatically]]>https://rocketeersapp.com/renew-ssl-certificates-automatically
/dev/null 2>&1' \
| sudo tee /etc/cron.d/certbot
```
Breaking that down:
- `0 0 * * *` runs it every day at midnight.
- `--quiet` keeps it silent unless something actually happens.
- `--post-hook "service nginx reload"` reloads Nginx **only** when a certificate was renewed, so it isn't reloading needlessly every day.
Running daily means that even if one renewal fails, you have ~30 days of retries before the certificate actually expires.
## The systemd alternative
On modern Ubuntu, Certbot often installs a `systemd` timer that does the same job. Check whether one is already active before adding a cron job:
```bash
systemctl list-timers | grep certbot
```
If you see `certbot.timer`, renewal is already scheduled — you only need to make sure a reload hook is configured. Use one mechanism or the other, not both.
## Confirm what's scheduled to renew
List every certificate Certbot manages and its expiry date:
```bash
sudo certbot certificates
```
For peace of mind, [check the expiry of the live certificate](/check-ssl-certificate-expiration) the way a browser sees it, and consider a monitoring alert so you hear about a stalled renewal long before visitors do.
## Let Rocketeers handle it
Automatic renewal is a chain — the cron job has to exist, the reload hook has to fire, the DNS or HTTP challenge has to keep working, and someone has to notice if a renewal quietly fails three months from now. Rocketeers renews every certificate across every server it manages and reloads the web server for you, and it surfaces any failure so a certificate never silently lapses. If you'd rather not run certificates on the origin at all, you can also [terminate SSL at Cloudflare](/a-plus-grade-ssl-using-cloudflare).]]>
2026-06-30T00:00:00+00:00<![CDATA[How to install PHP on Ubuntu]]>https://rocketeersapp.com/how-to-install-php2026-06-30T00:00:00+00:00<![CDATA[Important PHP config options]]>https://rocketeersapp.com/important-php-config-options2026-06-30T00:00:00+00:00<![CDATA[Setting process priority for Laravel Horizon workers]]>https://rocketeersapp.com/laravel-horizon-nice-process-priority
[
'production' => [
'supervisor-1' => [
'connection' => 'redis',
'queue' => ['default'],
'balance' => 'auto',
'processes' => 20,
'nice' => -5,
],
],
],
```
Horizon calls PHP's `proc_nice()` when it starts each worker.
## Permissions
Raising the nice value (e.g. `0 → 10`) works for any user. Lowering it (e.g. `0 → -5`) requires either root or the `CAP_SYS_NICE` capability. Without those privileges Horizon throws:
```
proc_nice(): Operation not permitted
```
To grant the capability to PHP without running as root:
```bash
sudo setcap cap_sys_nice=eip /usr/bin/php8.4
```
Verify it was applied:
```bash
getcap /usr/bin/php8.4
# /usr/bin/php8.4 cap_sys_nice=eip
```
Note: this grants the capability to the binary itself, so any PHP script running under that binary can adjust process priorities.
## Apply the changes
```bash
php artisan config:clear
php artisan horizon:terminate
```
If Horizon is managed by Supervisor:
```bash
sudo supervisorctl restart horizon:*
```
## Reverting
Remove the capability from the PHP binary:
```bash
sudo setcap -r /usr/bin/php8.4
```
No output from `getcap` afterwards means no capabilities are set. Also set `'nice' => 0` in `config/horizon.php` (or remove the key entirely) and restart Horizon.]]>
2026-06-24T00:00:00+00:00<![CDATA[403 Forbidden in nginx]]>https://rocketeersapp.com/403-forbidden-nginx2026-06-23T00:00:00+00:00<![CDATA[How to enable and configure OPcache for faster PHP]]>https://rocketeersapp.com/enable-opcache-php2026-06-23T00:00:00+00:00<![CDATA[A complete guide to caching in Laravel]]>https://rocketeersapp.com/laravel-cache
addMinutes(10)); // store with TTL
Cache::get('key', 'default'); // read, with fallback
Cache::has('key'); // existence check
Cache::forever('key', 'value'); // no expiry
Cache::forget('key'); // delete one key
```
The method you'll reach for most is `remember()`. It returns the cached value if present, otherwise runs the closure, stores the result, and returns it, so the slow path runs only on a miss:
```php
$users = Cache::remember('users.active', now()->addHour(), function () {
return User::where('active', true)
->withCount('orders')
->get();
});
```
That single call replaces the read/compute/write dance and is the canonical way to wrap a slow query. Use `rememberForever()` for values that never expire on a clock and are invalidated explicitly instead.
## Cache tags for grouped invalidation
When several keys belong together, **tags** let you invalidate them as a group instead of tracking every key by hand. Tags are only supported on the `redis` and `memcached` drivers, not `file` or `database`.
```php
Cache::tags(['users', 'billing'])->put('user.42.invoices', $invoices, 3600);
// Later, blow away everything tagged "users"
Cache::tags(['users'])->flush();
```
This is ideal for per-model caches: tag every entry for a user with `user.{id}`, then flush that one tag when the user changes, leaving the rest of the cache untouched.
## Application caching vs data caching
There's a second kind of caching in Laravel that has nothing to do with the `Cache` facade: **application/config caching**. These Artisan commands compile framework files into a single fast-loading file and matter most in production.
```bash
php artisan config:cache # merge all config into one cached file
php artisan route:cache # compile route definitions
php artisan view:cache # precompile Blade templates
```
Run these on deploy. The catch with `config:cache` is that `env()` calls outside of config files return `null` once config is cached, so read environment values through `config()` only. These caches are about boot speed; the `Cache` facade is about your data. They are independent systems with independent clear commands.
For the bigger picture on tuning a production app, see the [Laravel performance guide](/laravel-performance), and pair the config caches with [OPcache enabled in PHP](/enable-opcache-php) for the largest boot-time gains.
## Clearing the cache
Data cache and application caches clear separately:
```bash
php artisan cache:clear # flush the data cache (Cache facade)
php artisan config:clear # drop cached config
php artisan route:clear # drop cached routes
php artisan view:clear # drop compiled views
php artisan optimize:clear # all of the above at once
```
For the full rundown of when and why to run each, see [clearing the cache in Laravel](/clear-cache-laravel). If you're on Redis specifically and need to flush at the store level, see [clearing the Redis cache](/clear-redis-cache).
## Choosing a driver
A quick decision guide:
- **Local / tiny single server:** `file` — no dependencies, good enough.
- **Tests:** `array` — isolated per request, nothing to clean up.
- **Multi-server, no Redis yet:** `database` — shared and persistent, at some DB cost.
- **Production:** `redis` — fast, shared, supports tags and locks. The recommended default.
If you need cache tags, you must be on `redis` or `memcached`; `file` and `database` silently don't support them.
## Conclusion
The Laravel cache gives you one API over many backends: configure the store in `.env`, wrap slow work in `Cache::remember()`, group related keys with tags for clean invalidation, and keep application/config caching separate in your deploy step. Use Redis in production, and when something looks stale, reach for `cache:clear` or `optimize:clear` before you start debugging.]]>
2026-06-23T00:00:00+00:00<![CDATA[How to send GET and POST requests with curl]]>https://rocketeersapp.com/curl-post-get-api-requests2026-06-23T00:00:00+00:00<![CDATA[ERR_TOO_MANY_REDIRECTS (redirect loop)]]>https://rocketeersapp.com/err-too-many-redirects
withMiddleware(function (Middleware $middleware) {
$middleware->trustProxies(at: '*', headers:
Request::HEADER_X_FORWARDED_FOR |
Request::HEADER_X_FORWARDED_HOST |
Request::HEADER_X_FORWARDED_PORT |
Request::HEADER_X_FORWARDED_PROTO
);
})
```
### Check your nginx redirect
A correct HTTP→HTTPS redirect redirects only plain HTTP, and the HTTPS server block must not redirect again:
```nginx
server {
listen 80;
server_name example.com;
return 301 https://$host$request_uri;
}
server {
listen 443 ssl;
server_name example.com;
# serve the site here, do NOT redirect to https again
}
```
### Diagnose the loop
Follow the redirect chain from the command line to see exactly where it loops:
```bash
curl -sIL https://example.com | grep -i location
```
If you see the same two URLs alternating, you've found your loop.]]>
2026-06-23T00:00:00+00:00<![CDATA[git stash pop vs apply: save and restore changes]]>https://rocketeersapp.com/git-stash-pop2026-06-23T00:00:00+00:00<![CDATA[Address already in use (port already bound)]]>https://rocketeersapp.com/address-already-in-use-port
# if it ignores that:
kill -9
```
To kill whatever is on a port in one step:
```bash
sudo fuser -k 80/tcp
```
### Or use a different port
If you actually want both running, change the port of the one you're starting. For `artisan serve`:
```bash
php artisan serve --port=8001
```
### Crashed process, port still held
A port can stay in `TIME_WAIT` briefly after a crash. Wait a few seconds and retry, or confirm with `ss` that nothing still owns it before restarting.]]>
2026-06-23T00:00:00+00:00<![CDATA[npm ci vs npm install: when to use which]]>https://rocketeersapp.com/npm-ci-vs-npm-install
` |
| CI / CD pipelines | `npm ci` |
| Production / Docker builds | `npm ci` |
The rule of thumb: if you want reproducible, lockfile-exact installs, use `npm ci`. If you intend to change your dependencies, use `npm install`. Because `npm ci` wipes `node_modules`, it also clears up the kind of half-installed state that otherwise has people deleting the folder by hand.]]>
2026-06-23T00:00:00+00:00<![CDATA[How to generate a CSR with OpenSSL]]>https://rocketeersapp.com/generate-csr-with-openssl2026-06-23T00:00:00+00:00<![CDATA[How to delete a local (and remote) Git branch]]>https://rocketeersapp.com/git-delete-local-branch2026-06-23T00:00:00+00:00<![CDATA[CORS error: No Access-Control-Allow-Origin header]]>https://rocketeersapp.com/cors-error-no-access-control-allow-origin
['api/*', 'sanctum/csrf-cookie'],
'allowed_methods' => ['*'],
'allowed_origins' => ['https://app.example.com'],
'allowed_headers' => ['*'],
'supports_credentials' => true,
```
Set `supports_credentials` to `true` only if you send cookies, and in that case `allowed_origins` cannot be `*`, it must list explicit origins. Clear config after editing:
```bash
php artisan config:clear
```
### nginx
If you serve the API directly through nginx, add the headers in the relevant `location` block and answer the preflight `OPTIONS` request:
```nginx
location /api/ {
add_header 'Access-Control-Allow-Origin' 'https://app.example.com' always;
add_header 'Access-Control-Allow-Methods' 'GET, POST, PUT, DELETE, OPTIONS' always;
add_header 'Access-Control-Allow-Headers' 'Authorization, Content-Type' always;
if ($request_method = OPTIONS) {
return 204;
}
}
```
### Don't "fix" it in the browser
Disabling web security with a browser flag or a proxy extension only hides the error on your machine, every real visitor still gets blocked. CORS must be solved on the server that owns the API.]]>
2026-06-23T00:00:00+00:00<![CDATA[No application encryption key has been specified]]>https://rocketeersapp.com/no-application-encryption-key-has-been-specified2026-06-23T00:00:00+00:00<![CDATA[MySQL max_allowed_packet: packet too large]]>https://rocketeersapp.com/mysql-max-allowed-packet-packet-too-large2026-06-23T00:00:00+00:00<![CDATA[How database indexing works (with MySQL examples)]]>https://rocketeersapp.com/database-indexing
`, `<`, `BETWEEN`) and `ORDER BY` without sorting afterwards.
The trade-off: the tree has to stay sorted, so every `INSERT`, `UPDATE`, and `DELETE` has to update every affected index too. More on that cost below.
## Creating an index in MySQL
Say you frequently look up users by email:
```sql
SELECT * FROM users WHERE email = 'jane@example.com';
```
If `email` isn't indexed, that's a full table scan. Add an index:
```sql
CREATE INDEX idx_users_email ON users (email);
```
Or while creating/altering the table:
```sql
ALTER TABLE users ADD INDEX idx_users_email (email);
```
If the column should be unique (like an email), use a unique index instead, which enforces uniqueness *and* speeds up lookups:
```sql
ALTER TABLE users ADD UNIQUE INDEX idx_users_email (email);
```
In a Laravel migration the equivalent is:
```php
$table->string('email')->unique(); // unique index
$table->index('last_login_at'); // plain index
```
## Verify the index is actually used
Adding an index is only half the job, you need to confirm MySQL uses it. Put `EXPLAIN` in front of your query:
```sql
EXPLAIN SELECT * FROM users WHERE email = 'jane@example.com';
```
Look at two columns:
- **`type`** — `ALL` means a full table scan (bad). `ref`, `eq_ref`, or `const` means an index is being used (good).
- **`key`** — the index MySQL chose. `NULL` here means no index was used.
If `key` is `NULL` after you added an index, the query usually isn't written in an index-friendly way (see common mistakes below).
## What to index
Index the columns that appear in:
- **`WHERE` filters** — `WHERE status = 'active'`
- **`JOIN` conditions** — the foreign-key columns on both sides
- **`ORDER BY` / `GROUP BY`** — an index can return rows already sorted, skipping a separate sort step
Foreign keys are a common blind spot. A column like `posts.user_id` used in joins should almost always be indexed, otherwise every join does a scan.
## Composite indexes and the leftmost-prefix rule
When a query filters on several columns together, a **composite index** beats several single-column ones:
```sql
ALTER TABLE orders ADD INDEX idx_orders_user_status (user_id, status);
```
This index helps queries that filter on `user_id`, or on `user_id` **and** `status` together:
```sql
SELECT * FROM orders WHERE user_id = 42 AND status = 'paid';
```
The catch is the **leftmost-prefix rule**: MySQL can only use the index left-to-right. The index above helps `user_id` alone, and `user_id + status`, but **not** `status` alone, because `status` isn't the leftmost column. Order the columns by how you actually query them.
## The cost of indexes
Indexes are not free, so don't index every column:
- **Slower writes** — every `INSERT`/`UPDATE`/`DELETE` must update each index. Over-indexing a write-heavy table hurts.
- **Disk and memory** — indexes take space and compete for the InnoDB buffer pool.
- **Maintenance** — redundant indexes (e.g. an index on `(a)` when you already have `(a, b)`) waste resources for no gain.
A good rule of thumb: add indexes to support your real, slow queries, then remove ones that `EXPLAIN` never chooses.
## Common mistakes
- **Wrapping the column in a function** — `WHERE DATE(created_at) = '2026-06-23'` can't use an index on `created_at`. Rewrite as a range: `WHERE created_at >= '2026-06-23' AND created_at < '2026-06-24'`.
- **Leading wildcards** — `WHERE name LIKE '%smith'` can't use an index; `LIKE 'smith%'` can.
- **Indexing low-cardinality columns** — an index on a boolean or a `status` with two values rarely helps on its own.
- **Hitting the key-length limit** — very long `VARCHAR` indexes can fail on older MySQL. See [MySQL 1071: specified key was too long](/mysql-1071-specified-key-was-too-long).
## Conclusion
Indexing is the first place to look when a query is slow. Find the columns in your `WHERE`, `JOIN`, and `ORDER BY` clauses, add a focused index, and confirm with `EXPLAIN` that MySQL uses it, while keeping an eye on write cost so you don't over-index.
If you're still on an older MySQL release, upgrading also unlocks better indexing limits and a smarter optimizer, see [upgrading MySQL 5.7 to 8.0 on Ubuntu](/upgrade-mysql-5-7-to-8-0-ubuntu).]]>
2026-06-23T00:00:00+00:00<![CDATA[curl (60) SSL certificate problem: unable to get local issuer certificate]]>https://rocketeersapp.com/curl-60-ssl-certificate-problem-unable-to-get-local-issuer-certificate2026-06-23T00:00:00+00:00<![CDATA[Essential Linux command line basics for developers]]>https://rocketeersapp.com/linux-command-line-basics
notes.txt # write to a file (OVERWRITES it)
echo "more" >> notes.txt # append to a file (keeps existing content)
```
The difference between `>` and `>>` matters: a single `>` wipes the file first. Get them mixed up and you'll lose the contents of a file you meant to add to.
## A quick word on permissions
Run `ls -l` and you'll see strings like `-rwxr-xr--` at the start of each line. Those are permissions: read (`r`), write (`w`), and execute (`x`), shown for the owner, the group, and everyone else. When a script "won't run" or you get a "permission denied", this is usually why. The full story, including `chmod` and the numbers like `755`, is in the [change file permissions with chmod guide](/change-file-permissions-chmod-linux).
## Where to go next
These basics get you around, but the real productivity comes from a handful of focused tools:
- Finding files by name or type: [find files on the Linux command line](/find-files-linux-command).
- Searching inside files for text: [search files with grep](/search-files-grep-command).
- Bundling and compressing directories: [create and extract tar archives](/create-extract-tar-archives-linux).
- Working on a remote machine: [connect to a server with SSH](/connect-to-server-ssh-command).
Pick one command, use it for real on something you're actually doing, and it sticks. That beats memorizing a cheat sheet every time.]]>
2026-06-23T00:00:00+00:00<![CDATA[NET::ERR_CERT_AUTHORITY_INVALID]]>https://rocketeersapp.com/net-err-cert-authority-invalid2026-06-23T00:00:00+00:00<![CDATA[What is an SSH key]]>https://rocketeersapp.com/what-is-an-ssh-key2026-06-23T00:00:00+00:00<![CDATA[nginx rewrite or internal redirection cycle]]>https://rocketeersapp.com/nginx-rewrite-or-internal-redirection-cycle2026-06-23T00:00:00+00:00<![CDATA[docker compose up: options and common flags]]>https://rocketeersapp.com/docker-compose-up2026-06-23T00:00:00+00:00<![CDATA[How to search file contents with grep]]>https://rocketeersapp.com/search-files-grep-command2026-06-23T00:00:00+00:00<![CDATA[SSL handshake failed in nginx (ERR_SSL_PROTOCOL_ERROR)]]>https://rocketeersapp.com/ssl-handshake-failed-nginx
/dev/null | openssl x509 -noout -dates
```
And read the nginx error log:
```bash
tail -f /var/log/nginx/error.log
```
## Solution
### Renew an expired certificate
With Certbot:
```bash
sudo certbot renew
sudo systemctl reload nginx
```
Automate renewal so it never expires again, Certbot installs a timer for this by default.
### Serve the full chain
The `ssl_certificate` directive must point at the **full chain** (your certificate followed by the intermediates), not just the leaf certificate:
```nginx
ssl_certificate /etc/letsencrypt/live/example.com/fullchain.pem;
ssl_certificate_key /etc/letsencrypt/live/example.com/privkey.pem;
```
A leaf-only certificate works in some browsers and fails in others, a classic intermittent handshake failure.
### Enforce modern protocols
```nginx
ssl_protocols TLSv1.2 TLSv1.3;
```
Validate and reload after any change:
```bash
nginx -t && systemctl reload nginx
```
For a hardened SSL setup behind a CDN, see [an A+ grade SSL using Cloudflare](/a-plus-grade-ssl-using-cloudflare). If the chain problem shows up in command-line tools rather than browsers, see [curl (60) SSL certificate problem](/curl-60-ssl-certificate-problem-unable-to-get-local-issuer-certificate). When these same problems reach a visitor's browser, they see [your connection is not private](/your-connection-is-not-private) or [NET::ERR_CERT_AUTHORITY_INVALID](/net-err-cert-authority-invalid).]]>
2026-06-23T00:00:00+00:00<![CDATA[PHP file upload exceeds upload_max_filesize]]>https://rocketeersapp.com/php-file-upload-exceeds-upload-max-filesize2026-06-23T00:00:00+00:00<![CDATA[Redis connection refused in Laravel]]>https://rocketeersapp.com/redis-connection-refused-laravel2026-06-23T00:00:00+00:00<![CDATA[MySQL 1071: Specified key was too long (Laravel migration)]]>https://rocketeersapp.com/mysql-1071-specified-key-was-too-long
string('email', 191)->unique();
```]]>
2026-06-23T00:00:00+00:00<![CDATA[The complete guide to the curl command]]>https://rocketeersapp.com/curl-command-complete-guide2026-06-23T00:00:00+00:00<![CDATA[504 Gateway Timeout in nginx]]>https://rocketeersapp.com/504-gateway-timeout-nginx2026-06-23T00:00:00+00:00<![CDATA[Your connection is not private]]>https://rocketeersapp.com/your-connection-is-not-private
/dev/null | openssl x509 -noout -dates
```
### Cover every domain the site answers on
A `COMMON_NAME_INVALID` error means the certificate is missing a name. Issue it for both the apex and `www` (and any subdomains you serve):
```bash
sudo certbot --nginx -d example.com -d www.example.com
```
### Serve the full chain
If the code is `AUTHORITY_INVALID`, point nginx at `fullchain.pem`, not the leaf-only `cert.pem`, so the browser can build the trust chain:
```nginx
ssl_certificate /etc/letsencrypt/live/example.com/fullchain.pem;
```
Then validate and reload:
```bash
nginx -t && systemctl reload nginx
```
For the underlying TLS negotiation failures behind these warnings, see [SSL handshake failed in nginx](/ssl-handshake-failed-nginx), and for a hardened setup, [an A+ grade SSL using Cloudflare](/a-plus-grade-ssl-using-cloudflare).]]>
2026-06-23T00:00:00+00:00<![CDATA[MySQL ERROR 1205: Lock wait timeout exceeded]]>https://rocketeersapp.com/mysql-1205-lock-wait-timeout-exceeded
;
```
### Keep transactions short
The durable fix is to hold locks for as little time as possible. Don't do slow work inside a transaction, no external API calls, no waiting on user input, no heavy computation between `BEGIN` and `COMMIT`. In Laravel:
```php
// Do the slow part first, outside the transaction
$data = $api->fetch();
DB::transaction(function () use ($data) {
// only fast writes in here
Order::create($data);
});
```
### Raise the timeout (last resort)
If a particular job legitimately needs longer, raise the wait timeout rather than leaving it default:
```ini
[mysqld]
innodb_lock_wait_timeout = 120
```
But treat this as a stopgap, a growing lock-wait time usually points at transactions that are too long or contention that needs a schema or indexing fix. Related: [MySQL 1040 too many connections](/mysql-1040-too-many-connections) when stuck transactions also exhaust connections.]]>
2026-06-23T00:00:00+00:00<![CDATA[Getting started with the AWS CLI]]>https://rocketeersapp.com/getting-started-aws-cli`, and `aws help` documents each one. Tab completion is worth setting up too. With credentials configured and v2 installed, you've got the foundation for scripting anything AWS exposes.]]>
2026-06-23T00:00:00+00:00<![CDATA[500 Internal Server Error in Laravel]]>https://rocketeersapp.com/500-internal-server-error-laravel2026-06-23T00:00:00+00:00<![CDATA[CSRF token mismatch in Laravel]]>https://rocketeersapp.com/csrf-token-mismatch-laravel
@csrf
```
### AJAX requests
Expose the token in a meta tag and send it as a header on every request. With Axios:
```html
```
```javascript
window.axios.defaults.headers.common['X-CSRF-TOKEN'] =
document.querySelector('meta[name="csrf-token"]').content;
```
With jQuery:
```javascript
$.ajaxSetup({
headers: { 'X-CSRF-TOKEN': $('meta[name="csrf-token"]').attr('content') }
});
```
### Expired sessions
If users hit this after leaving a tab open, the token expired with the session. You can't avoid expiry entirely, but you can detect a 419 in your AJAX layer and refresh the page or token gracefully rather than failing silently.
### Stateless routes (APIs, webhooks)
CSRF protection is for session-based, browser-driven requests. For a stateless API or an incoming webhook it doesn't apply, exclude those routes and authenticate with tokens or signed URLs instead. See [disabling CSRF in Laravel](/disable-csrf-in-laravel) for how to exclude specific routes.]]>
2026-06-23T00:00:00+00:00<![CDATA[How to check your Ubuntu version from the command line]]>https://rocketeersapp.com/check-ubuntu-version-command-line2026-06-23T00:00:00+00:00<![CDATA[Brotli vs Gzip: which compression should you use?]]>https://rocketeersapp.com/brotli-vs-gzip2026-06-23T00:00:00+00:00<![CDATA[MySQL ERROR 1040: Too many connections]]>https://rocketeersapp.com/mysql-1040-too-many-connections2026-06-23T00:00:00+00:00<![CDATA[How to checkout a Git tag]]>https://rocketeersapp.com/git-checkout-tag2026-06-23T00:00:00+00:00<![CDATA[What port does SSH use (and how to change it)]]>https://rocketeersapp.com/ssh-port2026-06-23T00:00:00+00:00<![CDATA[MySQL ERROR 1698: Access denied for user 'root'@'localhost']]>https://rocketeersapp.com/mysql-1698-access-denied-auth-socket2026-06-23T00:00:00+00:00<![CDATA[How to copy files over SSH with scp]]>https://rocketeersapp.com/copy-files-over-ssh-scp`, where a remote location looks like `user@host:/path`.
## Local to remote
To upload a file from your machine to a server, put the remote location on the right:
```bash
scp ./backup.sql deploy@example.com:/var/www/backups/
```
This copies `backup.sql` into the `/var/www/backups/` directory on the server. If you want to rename it on the way, just include a filename in the destination path.
## Remote to local
Flip the arguments to download instead. Here the remote path is the source, and `.` is the current local directory:
```bash
scp deploy@example.com:/var/log/nginx/error.log .
```
## Copying directories with -r
By default `scp` only handles single files. To copy a whole directory and everything inside it, add `-r` (recursive):
```bash
scp -r ./public deploy@example.com:/var/www/app/
```
## Using a custom port with -P
If the server's SSH daemon listens on a non-standard port, pass it with `-P` (a capital P — lowercase `-p` preserves timestamps instead):
```bash
scp -P 2222 ./config.yml deploy@example.com:/etc/app/
```
## Using a specific key with -i
When the server expects a particular private key, point at it with `-i`. This is handy when you juggle several keys:
```bash
scp -i ~/.ssh/deploy_key ./release.tar.gz deploy@example.com:/tmp/
```
If you'd rather not type this every time, you can configure the key per host in `~/.ssh/config` and `scp` will pick it up automatically.
## Copying between two remote hosts
You don't even need the file to pass through your machine. Give two remote locations and `scp` copies directly between them:
```bash
scp deploy@host1.example.com:/data/dump.sql deploy@host2.example.com:/data/
```
Add `-3` if the two hosts can't reach each other directly and you want the transfer routed through your local machine instead.
## A few tips
You can combine flags, for example `scp -rP 2222` to recursively copy over a custom port. And if you're moving large directories around regularly, `rsync` is often a better fit since it only transfers what changed — but for a quick one-off copy, `scp` is hard to beat.]]>
2026-06-23T00:00:00+00:00<![CDATA[nginx: upstream sent too big header]]>https://rocketeersapp.com/nginx-upstream-sent-too-big-header2026-06-23T00:00:00+00:00<![CDATA[How to generate a self-signed certificate with OpenSSL]]>https://rocketeersapp.com/generate-self-signed-certificate-openssl2026-06-23T00:00:00+00:00<![CDATA[How to create and extract tar archives in Linux]]>https://rocketeersapp.com/create-extract-tar-archives-linux2026-06-23T00:00:00+00:00<![CDATA[No space left on device on Ubuntu]]>https://rocketeersapp.com/no-space-left-on-device-ubuntu2026-06-23T00:00:00+00:00<![CDATA[Vite manifest not found in Laravel]]>https://rocketeersapp.com/vite-manifest-not-found-laravel2026-06-23T00:00:00+00:00<![CDATA[How to optimize MySQL performance]]>https://rocketeersapp.com/optimize-mysql-performance2026-06-23T00:00:00+00:00<![CDATA[Git fatal: refusing to merge unrelated histories]]>https://rocketeersapp.com/git-refusing-to-merge-unrelated-histories2026-06-23T00:00:00+00:00<![CDATA[Convert SSL certificate formats with OpenSSL]]>https://rocketeersapp.com/convert-ssl-certificate-formats2026-06-23T00:00:00+00:00<![CDATA[git reset --hard explained (soft vs mixed vs hard)]]>https://rocketeersapp.com/git-reset-hard
```
Note that `reflog` only recovers committed work. Changes that were never committed and got discarded by `--hard` cannot be recovered. When in doubt, [stash](/git-stash-pop) your changes instead of resetting.]]>
2026-06-23T00:00:00+00:00<![CDATA[How to generate an SSH key]]>https://rocketeersapp.com/generate-ssh-key2026-06-23T00:00:00+00:00<![CDATA[How to clear the Redis cache]]>https://rocketeersapp.com/clear-redis-cache
SELECT 2
OK
127.0.0.1:6379[2]> FLUSHDB
OK
```
If `redis-cli` itself can't connect, that's a separate problem, see [Redis connection refused in Laravel](/redis-connection-refused-laravel).
## Clear specific keys
Flushing is rarely what you want in production. To remove one key, use `DEL`:
```bash
redis-cli DEL session:abc123
redis-cli DEL user:42 user:43 user:44
```
To delete everything matching a pattern, you might reach for `KEYS`, **don't**. `KEYS` scans the entire keyspace in a single blocking operation; on a large dataset it freezes the server for the duration. Use `SCAN`, which iterates in small batches, and pipe the results into `DEL`:
```bash
redis-cli --scan --pattern 'session:*' | xargs -L 100 redis-cli DEL
```
`--scan` cursors through the keyspace without blocking, and `-L 100` deletes in chunks of 100 keys so you don't build one enormous command. This is the safe way to clear the Redis cache for a subset of keys on a live instance.
## Async (non-blocking) flush
`FLUSHDB` and `FLUSHALL` are synchronous by default: on a cache holding millions of keys, freeing that memory blocks the server. The `ASYNC` modifier hands the cleanup to a background thread so the command returns immediately:
```bash
redis-cli FLUSHDB ASYNC
redis-cli FLUSHALL ASYNC
```
Use `ASYNC` on any large production cache. The keys disappear right away; only the memory reclamation happens in the background.
## Clearing the cache from Laravel
If Redis is your Laravel cache store, you rarely touch `redis-cli` at all. The Artisan command clears the default store:
```bash
php artisan cache:clear
```
The programmatic equivalent is `Cache::flush()`:
```php
use Illuminate\Support\Facades\Cache;
Cache::flush();
```
To clear a specific store instead of the default, name it:
```php
Cache::store('redis')->flush();
```
```bash
php artisan cache:clear --store=redis
```
One caveat: `flush()` clears the *entire* store, including any non-cache data sharing that Redis database (sessions, queues). If you only want to drop tagged entries, flush by tag:
```php
Cache::tags(['users'])->flush();
```
For the full set of Laravel options see [clearing the cache in Laravel](/clear-cache-laravel) and the [Laravel cache](/laravel-cache) reference.
## A word of caution in production
Clearing the cache in production isn't free. When you flush, every subsequent request misses the cache at once and falls through to the database. That sudden surge, a **cache stampede** or **thundering herd**, can overload the database hard enough to take the site down, exactly when you were trying to fix it.
To soften the impact:
- Clear specific keys with `SCAN` + `DEL` instead of a full flush whenever you can.
- Warm critical keys right after flushing.
- Use `FLUSHALL ASYNC` so the flush itself doesn't block Redis.
## Conclusion
To clear the Redis cache, match the tool to the blast radius: `DEL` or `SCAN` for individual keys, `FLUSHDB` for one database, `FLUSHALL` for the whole instance, and `ASYNC` on anything large. From Laravel, prefer `php artisan cache:clear` or `Cache::flush()`. In production, lean toward targeted deletes and be ready for the cache stampede a full flush can trigger.]]>
2026-06-23T00:00:00+00:00<![CDATA[docker exec: run a command in a running container]]>https://rocketeersapp.com/docker-exec2026-06-23T00:00:00+00:00<![CDATA[SSH Permission denied (publickey)]]>https://rocketeersapp.com/ssh-permission-denied-publickey2026-06-23T00:00:00+00:00<![CDATA[Laravel failed to open stream: Permission denied]]>https://rocketeersapp.com/laravel-failed-to-open-stream-permission-denied2026-06-23T00:00:00+00:00<![CDATA[How to check SSL certificate expiration]]>https://rocketeersapp.com/check-ssl-certificate-expiration
/dev/null \
| openssl x509 -noout -dates
```
You'll get the start and end of the validity window:
```bash
notBefore=Mar 1 00:00:00 2026 GMT
notAfter=May 30 23:59:59 2026 GMT
```
To see only the expiry date, swap `-dates` for `-enddate`:
```bash
echo | openssl s_client -servername example.com -connect example.com:443 2>/dev/null \
| openssl x509 -noout -enddate
```
## Check a certificate file on disk
If you have the certificate as a local file:
```bash
openssl x509 -in certificate.pem -noout -enddate
```
This works on any PEM or CRT file. For other formats, see [converting certificate formats](/convert-ssl-certificate-formats) first.
## Check whether it expires within N days
The `-checkend` flag is built for scripts and monitoring. It takes a number of seconds and exits non-zero if the certificate expires within that window. This checks for the next 30 days (30 × 86400 = 2592000 seconds):
```bash
openssl x509 -in certificate.pem -noout -checkend 2592000
```
```bash
echo $? # 0 = still valid, 1 = expires within 30 days
```
Wire that exit code into a cron job or a monitoring check and you'll get warned before a certificate ever lapses. If your certificate is valid but the connection still fails, the cause is often a [missing certificate chain](/what-is-an-ssl-certificate-chain) rather than the expiry date.]]>
2026-06-23T00:00:00+00:00<![CDATA[How to run a command on a remote server over SSH]]>https://rocketeersapp.com/run-command-over-ssh
server-syslog.txt
ssh deploy@example.com 'df -h' | grep '/dev/sda1'
```
## Running a local script on the server
A neat trick: you can feed a script from your machine into a remote shell without copying it over first. Pipe it into `bash -s`:
```bash
ssh deploy@example.com 'bash -s' < ./provision.sh
```
The remote `bash -s` reads the script from standard input, which `ssh` pipes from your local file. You can even pass arguments to the script after `bash -s`:
```bash
ssh deploy@example.com 'bash -s' -- arg1 arg2 < ./provision.sh
```
This is great for ad-hoc provisioning or maintenance scripts you keep locally but want to run on several servers without uploading them each time.]]>
2026-06-23T00:00:00+00:00<![CDATA[How to change the SSH port on Ubuntu]]>https://rocketeersapp.com/change-ssh-port-ubuntu2026-06-23T00:00:00+00:00<![CDATA[Fix: Cannot connect to the Docker daemon at unix:///var/run/docker.sock]]>https://rocketeersapp.com/cannot-connect-to-docker-daemon2026-06-23T00:00:00+00:00<![CDATA[How to connect to a server with the ssh command]]>https://rocketeersapp.com/connect-to-server-ssh-command2026-06-23T00:00:00+00:00<![CDATA[How to enable Gzip and Brotli compression in Nginx]]>https://rocketeersapp.com/enable-gzip-compression-nginx2026-06-23T00:00:00+00:00<![CDATA[PHP Warning: Undefined array key]]>https://rocketeersapp.com/undefined-array-key-php
input('page', 1);
```
If the underlying value is an object rather than an array and you're calling a method on it, see [Call to a member function on null](/call-to-a-member-function-on-null).]]>
2026-06-23T00:00:00+00:00<![CDATA[How to make a script executable with chmod +x]]>https://rocketeersapp.com/make-script-executable-chmod-x2026-06-23T00:00:00+00:00<![CDATA[SQLSTATE[23000] 1062 Duplicate entry]]>https://rocketeersapp.com/sqlstate-23000-1062-duplicate-entry
validate([
'email' => 'required|email|unique:users,email',
]);
```
### Use upsert / updateOrCreate for idempotent writes
If re-running the operation should update rather than fail, don't blind-insert:
```php
User::updateOrCreate(
['email' => $email], // match on this
['name' => $name], // update these
);
```
For bulk operations, `upsert()` does the same in a single query.
### Reset a broken auto-increment
If the clash is on the primary key after an import, realign the counter to just past the highest existing id:
```sql
ALTER TABLE users AUTO_INCREMENT = 1;
```
MySQL bumps the value to the next free id automatically.
### Re-running seeders
If a seeder keeps colliding, either make it idempotent with `updateOrCreate`, or refresh the schema first on a development database:
```bash
php artisan migrate:fresh --seed
```
Remember `migrate:fresh` drops all tables, so never run it where there's data you need.]]>
2026-06-23T00:00:00+00:00<![CDATA[PHP Fatal error: Allowed memory size exhausted]]>https://rocketeersapp.com/php-allowed-memory-size-exhausted2026-06-23T00:00:00+00:00<![CDATA[502 Bad Gateway in nginx]]>https://rocketeersapp.com/502-bad-gateway-nginx2026-06-23T00:00:00+00:00<![CDATA[PHP: Call to a member function on null]]>https://rocketeersapp.com/call-to-a-member-function-on-null
format()`, `->name`, `->save()`) on something that was `null` instead of the object you expected. PHP can't call a method on nothing, so it throws. In a web request this reaches visitors as a [500 Internal Server Error](/500-internal-server-error-laravel).
The method name in the message is a strong clue: it tells you *which* object was missing.
## Why do I see this error
- A database query returned no row, so the model is `null`.
- A relationship isn't loaded or doesn't exist for this record.
- An optional value (a nullable column, a missing config key) is genuinely empty.
- A function you assumed always returns an object returned `null` on failure.
## Solution
### Find the null
In Laravel, `find()` and `first()` return `null` when nothing matches. Calling a method on that result fails:
```php
$user = User::find($id); // null if no such user
echo $user->name; // Call to a member function on null
```
### Handle the empty case
Decide what should happen when it's missing. To 404 automatically, use `findOrFail()`:
```php
$user = User::findOrFail($id); // throws a 404 instead of returning null
```
To provide a fallback, check first or use the nullsafe operator (PHP 8+):
```php
// guard explicitly
if ($user) {
echo $user->name;
}
// or the nullsafe operator: returns null instead of erroring
echo $user?->profile?->bio ?? 'No bio';
```
### Relationships
A relationship that hasn't been set returns `null` too. The nullsafe operator and `optional()` helper both guard against it:
```php
$company = $user->company?->name ?? 'Independent';
```
The fix is rarely to suppress the error, it's to decide deliberately what the empty case should do. A related strictness error is the [undefined array key](/undefined-array-key-php) warning in PHP 8.]]>
2026-06-23T00:00:00+00:00<![CDATA[Target class does not exist in Laravel]]>https://rocketeersapp.com/target-class-does-not-exist-laravel2026-06-23T00:00:00+00:00<![CDATA[How to change file permissions with chmod]]>https://rocketeersapp.com/change-file-permissions-chmod-linux2026-06-23T00:00:00+00:00<![CDATA[How to find your IP address from the Linux command line]]>https://rocketeersapp.com/find-ip-address-linux-command-line2026-06-23T00:00:00+00:00<![CDATA[How to rename a Git branch (local and remote)]]>https://rocketeersapp.com/git-rename-branch2026-06-23T00:00:00+00:00<![CDATA[MySQL ERROR 2006: server has gone away]]>https://rocketeersapp.com/mysql-2006-server-has-gone-away2026-06-23T00:00:00+00:00<![CDATA[How to improve Laravel performance]]>https://rocketeersapp.com/laravel-performance
author->name; // queries the authors table every iteration
}
```
Eager load the relationship with `with()` so it's fetched in a single extra query:
```php
// 2 queries total, no matter how many posts
$posts = Post::with('author')->get();
foreach ($posts as $post) {
echo $post->author->name; // already loaded
}
```
You can catch these automatically in development with `Model::preventLazyLoading()` in a service provider, which throws when a relationship is lazy-loaded.
Eager loading reduces the *number* of queries. The speed of each query is a database concern: make sure the foreign-key columns you join on are indexed, or every query still does a full table scan. See [how database indexing works](/database-indexing) for the underlying DB side.
## Offload slow work to queues
Sending email, processing images, calling third-party APIs, generating PDFs, none of it needs to happen inside the request. Push it onto a queue so the user gets an instant response and the work runs in the background.
```php
// Instead of sending inline
Mail::to($user)->send(new WelcomeEmail($user));
// Queue it
Mail::to($user)->queue(new WelcomeEmail($user));
```
Any job can be queued by dispatching it:
```php
ProcessPodcast::dispatch($podcast);
```
Run a worker to process the queue, and keep it alive with a process manager like Supervisor:
```bash
php artisan queue:work --tries=3
```
This moves latency out of the request path, which is often the difference between a 1.5-second page and a 150-millisecond one.
## Use a fast cache and session driver
The default `file` driver writes cache and session data to disk, which is slow and doesn't scale across multiple servers. Switch to Redis for both.
```ini
CACHE_STORE=redis
SESSION_DRIVER=redis
QUEUE_CONNECTION=redis
```
Redis is an in-memory store, so reads and writes are sub-millisecond, and it works as a shared backend when you scale to more than one app server. See [using Redis for the Laravel cache](/laravel-cache) for setup and patterns. If your worker can't reach it, check [Redis connection refused in Laravel](/redis-connection-refused-laravel).
## Enable OPcache on the server
PHP recompiles your scripts to bytecode on every request unless OPcache is enabled. OPcache keeps the compiled bytecode in memory, eliminating that work entirely. It's the highest-impact server-side change you can make and applies to any PHP app. See [enabling OPcache in PHP](/enable-opcache-php) for the recommended `php.ini` settings, and [general PHP performance tuning](/php-performance) for more.
## Speed up the frontend
Backend speed is only half the page. Bundle and minify your assets with Vite, which ships with modern Laravel:
```bash
npm run build
```
This produces hashed, minified, tree-shaken bundles and lets the browser cache them aggressively. On the response side, cache rendered output for pages that don't change per-user (marketing pages, docs) and lean on HTTP caching headers so repeat visits skip the server entirely.
## Conclusion
Laravel performance comes down to a short checklist: run `php artisan optimize` and clear it on deploy, build the autoloader with `--optimize-autoloader --no-dev`, eliminate N+1 queries with `with()`, push slow work to queues, use Redis for cache and sessions, and enable OPcache. Do these and a stock Laravel app handles serious traffic before you ever need to think about the framework itself.]]>
2026-06-23T00:00:00+00:00<![CDATA[MySQL ERROR 1064: SQL syntax error]]>https://rocketeersapp.com/mysql-1064-sql-syntax-error2026-06-23T00:00:00+00:00<![CDATA[How to configure rate limiting in nginx]]>https://rocketeersapp.com/nginx-rate-limiting2026-06-23T00:00:00+00:00<![CDATA[How to sync files and directories with rsync]]>https://rocketeersapp.com/sync-files-rsync-command2026-06-23T00:00:00+00:00<![CDATA[PHP Fatal error: Class "X" not found]]>https://rocketeersapp.com/php-class-not-found2026-06-23T00:00:00+00:00<![CDATA[How to install the Xcode Command Line Tools on macOS]]>https://rocketeersapp.com/install-xcode-command-line-tools2026-06-23T00:00:00+00:00<![CDATA[GitHub Permission denied (publickey)]]>https://rocketeersapp.com/github-permission-denied-publickey
!`, your key works and the problem is the repository remote, not auth. If it says `Permission denied`, continue below.
### Generate a key if you don't have one
```bash
ssh-keygen -t ed25519 -C "you@example.com"
```
Press enter to accept the default location (`~/.ssh/id_ed25519`).
### Add the public key to GitHub
Copy the **public** key (`.pub`) and paste it into GitHub under Settings → SSH and GPG keys → New SSH key:
```bash
cat ~/.ssh/id_ed25519.pub
```
### Load the key into the agent
```bash
eval "$(ssh-agent -s)"
ssh-add ~/.ssh/id_ed25519
```
### Wrong remote protocol
If your account is set up for SSH but the repo was cloned over HTTPS (or the reverse), switch the remote URL:
```bash
git remote set-url origin git@github.com:you/repo.git
```
For the general server-side version of this error (your own servers rather than GitHub), see [SSH Permission denied (publickey)](/ssh-permission-denied-publickey).]]>
2026-06-23T00:00:00+00:00<![CDATA[How to find files in Linux with the find command]]>https://rocketeersapp.com/find-files-linux-command`, where the path is where to start searching.
## Find by name
Search by filename with `-name`. It matches the exact name, so use shell-style wildcards (quoted, so the shell doesn't expand them first):
```bash
find . -name '*.log'
```
If case shouldn't matter, use `-iname` instead. This matches `README`, `readme` and `ReadMe`:
```bash
find . -iname 'readme*'
```
## Find by type
Limit results to files or directories with `-type`. Use `f` for regular files and `d` for directories:
```bash
find /var/www -type f -name '*.php'
find /var/www -type d -name 'cache'
```
## Find by size
The `-size` flag matches on file size. Suffix the number with `k`, `M` or `G`, and prefix it with `+` for "larger than" or `-` for "smaller than":
```bash
find . -type f -size +100M
```
This finds files larger than 100 megabytes — handy for hunting down what's eating your disk.
## Find by modification time
`-mtime` matches by how many days ago a file was last modified. `-mtime -7` means changed within the last 7 days, while `+30` means older than 30 days:
```bash
find /tmp -type f -mtime +30
```
For finer control, `-mmin` works the same way but in minutes.
## Searching a specific path
The path argument can be anything — an absolute path, a relative one, or several at once:
```bash
find /etc /opt -name '*.conf'
```
## Acting on results with -exec
Beyond listing matches, `find` can run a command on each one with `-exec`. The `{}` is replaced by the filename and `\;` ends the command:
```bash
find . -name '*.tmp' -type f -exec rm {} \;
```
For deleting specifically, the built-in `-delete` is cleaner and avoids the "[argument list too long](/argument-list-too-long)" error you'd hit with `rm *`:
```bash
find ./logs -name '*.log' -type f -delete
```
You can chain `find` with other tools too. To search the contents of every matching file, pipe the names into [grep](/search-files-grep-command):
```bash
find . -name '*.php' -exec grep -l 'TODO' {} \;
```
Combine conditions freely — they're ANDed together — and `find` becomes a precise way to locate exactly the files you're after.]]>
2026-06-23T00:00:00+00:00<![CDATA[503 Service Unavailable]]>https://rocketeersapp.com/503-service-unavailable2026-06-23T00:00:00+00:00<![CDATA[Git fatal: not a git repository]]>https://rocketeersapp.com/git-not-a-git-repository2026-06-23T00:00:00+00:00<![CDATA[Composer out of memory (allowed memory size exhausted)]]>https://rocketeersapp.com/composer-out-of-memory-allowed-memory-size-exhausted2026-06-23T00:00:00+00:00<![CDATA[PHP Maximum execution time of N seconds exceeded]]>https://rocketeersapp.com/php-maximum-execution-time-exceeded2026-06-23T00:00:00+00:00<![CDATA[How to update Ubuntu from the command line]]>https://rocketeersapp.com/update-ubuntu-command-line2026-06-23T00:00:00+00:00<![CDATA[What is an SSL certificate chain]]>https://rocketeersapp.com/what-is-an-ssl-certificate-chain
fullchain.crt
```
Then point your web server at the combined file. In nginx:
```
ssl_certificate /etc/ssl/fullchain.crt;
ssl_certificate_key /etc/ssl/domain.key;
```
If you use Let's Encrypt, this is already done for you — always point `ssl_certificate` at `fullchain.pem`, not `cert.pem`.
After reloading the server, re-run the `openssl s_client` command above and confirm the full chain is now sent. Once the chain is complete, you can verify your overall configuration with the [SSLLabs test and aim for an A+ grade](/a-plus-grade-ssl-using-cloudflare).]]>
2026-06-23T00:00:00+00:00<![CDATA[SQLSTATE[HY000] [1045] Access denied for user]]>https://rocketeersapp.com/sqlstate-hy000-1045-access-denied-for-user2026-06-23T00:00:00+00:00<![CDATA[How to remove untracked files in Git (git clean)]]>https://rocketeersapp.com/git-remove-untracked-files2026-06-23T00:00:00+00:00<![CDATA[How to find and optimize slow MySQL queries]]>https://rocketeersapp.com/mysql-query-optimization
= '2026-06-23' AND created_at < '2026-06-24';
```
**Avoid a leading wildcard in `LIKE`.** `'%smith'` forces a scan; `'smith%'` can use the index because the prefix is fixed:
```sql
SELECT id FROM customers WHERE name LIKE 'smith%';
```
**Prefer range conditions and always limit large result sets.** Returning 100,000 rows to the application is slow regardless of indexing, page the results:
```sql
SELECT id, total FROM orders
WHERE customer_id = 42
ORDER BY created_at DESC
LIMIT 50;
```
## EXPLAIN ANALYZE on MySQL 8.0
`EXPLAIN` shows the optimizer's *plan*. On MySQL 8.0, `EXPLAIN ANALYZE` actually *runs* the query and reports real timings per step, so you can see where the time genuinely goes rather than relying on estimates:
```sql
EXPLAIN ANALYZE SELECT id, total FROM orders WHERE customer_id = 42;
```
If you're still on 5.7 you won't have this, and you're missing optimizer improvements and better index limits too, see [upgrading MySQL 5.7 to 8.0 on Ubuntu](/upgrade-mysql-5-7-to-8-0-ubuntu). Server-wide tuning (buffer pool size, connection limits) is a separate lever covered in [optimizing MySQL performance](/optimize-mysql-performance).
## Conclusion
MySQL query optimization is a loop, not a one-time fix: enable the slow query log to find the worst queries, run `EXPLAIN` to see why they're slow, then add a focused index or rewrite the query so the index can be used. Confirm every change with `EXPLAIN` before moving on, and keep watching the slow log as your data grows, the query that's fast today on ten thousand rows is the full table scan that pages you at ten million.]]>
2026-06-23T00:00:00+00:00<![CDATA[Git: Updates were rejected (non-fast-forward)]]>https://rocketeersapp.com/git-updates-were-rejected-non-fast-forward
main (non-fast-forward)
error: failed to push some refs to '...'
hint: Updates were rejected because the tip of your current branch is behind
hint: its remote counterpart.
```
A push can only "fast-forward" when your local branch is a direct continuation of the remote one. If someone else (or another machine of yours) pushed commits in the meantime, your branch has diverged, and Git rejects the push to avoid silently discarding their work.
## Why do I see this error
- A teammate pushed to the same branch before you.
- You pushed from another clone or worktree and forgot.
- The remote branch was amended or rebased, so the histories no longer line up.
## Solution
### Integrate the remote commits, then push
Fetch and merge the remote changes into your branch first:
```bash
git pull origin main
git push origin main
```
If you prefer a linear history without merge commits, rebase your work on top of theirs instead:
```bash
git pull --rebase origin main
git push origin main
```
Resolve any conflicts that come up, then push, this time it fast-forwards cleanly.
### Do not reach for --force
It's tempting to "fix" the rejection with `git push --force`, but on a shared branch that **deletes the commits the remote had that you didn't**, throwing away your teammate's work. Avoid it.
If you genuinely need to overwrite (for example, after intentionally rebasing your *own* feature branch), use the safer variant, which refuses if the remote moved in a way you haven't seen:
```bash
git push --force-with-lease
```
`--force-with-lease` aborts instead of clobbering if someone pushed since your last fetch, making it far safer than a blind `--force`. The related history error is covered in [Git fatal: refusing to merge unrelated histories](/git-refusing-to-merge-unrelated-histories).]]>
2026-06-23T00:00:00+00:00<![CDATA[SQLSTATE[42S02] Base table or view not found]]>https://rocketeersapp.com/sqlstate-42s02-base-table-or-view-not-found2026-06-23T00:00:00+00:00<![CDATA[SQLSTATE[HY000] [2002] Connection refused]]>https://rocketeersapp.com/sqlstate-hy000-2002-connection-refused2026-06-23T00:00:00+00:00<![CDATA[How to increase the PHP memory limit]]>https://rocketeersapp.com/increase-php-memory-limit2026-06-23T00:00:00+00:00<![CDATA[How to kill the process running on a port in Linux]]>https://rocketeersapp.com/kill-process-on-port-linux2026-06-23T00:00:00+00:00<![CDATA[How to generate SSH keys with ssh-keygen]]>https://rocketeersapp.com/generate-ssh-keys-ssh-keygen
> ~/.ssh/authorized_keys"
```
If the server still asks for a password or rejects the key, the [SSH permission denied (publickey) guide](/ssh-permission-denied-publickey) walks through the usual causes.
## Adding the key to ssh-agent
`ssh-agent` holds your decrypted key in memory so you only type the passphrase once per session. Start it and add your key:
```bash
eval "$(ssh-agent -s)"
ssh-add ~/.ssh/id_ed25519
```
On macOS, store the passphrase in the Keychain so it persists across reboots:
```bash
ssh-add --apple-use-keychain ~/.ssh/id_ed25519
```
## Adding the key to GitHub
To push and pull over SSH, GitHub needs your public key. Copy it to your clipboard:
```bash
# macOS
pbcopy < ~/.ssh/id_ed25519.pub
# Linux (X11)
xclip -sel clip < ~/.ssh/id_ed25519.pub
```
Then go to GitHub, open **Settings, SSH and GPG keys, New SSH key**, paste it, and save. Verify it works:
```bash
ssh -T git@github.com
```
You should see a greeting with your username. If you instead hit `Permission denied (publickey)`, the [GitHub publickey error guide](/github-permission-denied-publickey) covers the fixes. Once this is green, your key handles servers and Git for good.]]>
2026-06-23T00:00:00+00:00<![CDATA[How to clean up Docker with prune (images, volumes, system)]]>https://rocketeersapp.com/docker-prune2026-06-23T00:00:00+00:00<![CDATA[How to forward ports with SSH tunneling]]>https://rocketeersapp.com/ssh-tunnel-port-forwarding2026-06-23T00:00:00+00:00<![CDATA[How to setup OpenClaw securely on your own VPS]]>https://rocketeersapp.com/setup-openclaw-vps-securely
> .gitignore
```
Set appropriate file permissions:
```bash
chmod 600 .env
```
## Post-installation security checks
After installation, verify your security configuration:
**1. Check exposed ports**
```bash
sudo netstat -tulpn | grep LISTEN
```
You should only see SSH (port 22) and Docker internal services. The OpenClaw gateway should be listening on 127.0.0.1 only, not 0.0.0.0.
**2. Test authentication**
Try accessing the gateway without authentication to ensure it's properly protected:
```bash
curl http://localhost:8080
```
This should return an authentication error if properly configured.
**3. Review Docker container security**
```bash
# Check running containers
docker ps
# Review container logs for errors
docker compose logs --tail=100
```
## Maintenance and monitoring
**Regular security audits**
Schedule monthly security reviews:
- Check for unauthorized SSH access attempts: `sudo grep "Failed password" /var/log/auth.log`
- Review OpenClaw access logs for suspicious activity
- Update all dependencies and Docker images
- Verify firewall rules remain intact
**Automated backups**
Set up automated backups of your OpenClaw configuration and data:
```bash
# Create a backup script
cat > /root/backup-openclaw.sh << 'EOF'
#!/bin/bash
BACKUP_DIR="/backups/openclaw"
DATE=$(date +%Y%m%d_%H%M%S)
mkdir -p $BACKUP_DIR
cd /path/to/openclaw
# Backup configuration and data
tar -czf $BACKUP_DIR/openclaw_backup_$DATE.tar.gz \
.env \
docker-compose.yml \
data/
# Keep only last 30 days of backups
find $BACKUP_DIR -name "openclaw_backup_*.tar.gz" -mtime +30 -delete
EOF
chmod +x /root/backup-openclaw.sh
# Schedule daily backups via cron
(crontab -l 2>/dev/null; echo "0 2 * * * /root/backup-openclaw.sh") | crontab -
```
## Common security mistakes to avoid
1. **Exposing the gateway to 0.0.0.0** - Always bind to 127.0.0.1 and use tunneling
2. **Using weak or no authentication tokens** - Generate strong random tokens
3. **Running as root** - Create a dedicated user for OpenClaw
4. **Not updating regularly** - Set up automatic security updates
5. **Storing credentials in git** - Use environment variables and secure .env files
6. **Opening unnecessary firewall ports** - Only expose SSH, use tunnels for everything else
7. **Using default passwords** - Change all default credentials immediately
8. **Not monitoring logs** - Set up log monitoring and alerting
## Conclusion
OpenClaw is a powerful tool that requires careful security configuration. By following the practices outlined in this guide, you can deploy OpenClaw securely and avoid becoming part of the statistics of exposed instances.
Remember: security is not a one-time setup but an ongoing process. Regularly review your configuration, keep software updated, and monitor for suspicious activity.
The key principles are:
- Never expose OpenClaw directly to the internet
- Always require strong authentication
- Use SSH tunneling or Tailscale for access
- Keep software updated
- Monitor and audit regularly
With these measures in place, you can confidently run OpenClaw on your VPS while maintaining robust security.]]>
2026-02-04T00:00:00+00:00<![CDATA[How to get A+ grade SSL using Cloudflare]]>https://rocketeersapp.com/a-plus-grade-ssl-using-cloudflare2024-09-24T19:16:29+00:00<![CDATA[How to rename a MySQL database]]>https://rocketeersapp.com/rename-mysql-database2024-09-25T07:47:45+00:00<![CDATA[How many CPU cores on Ubuntu]]>https://rocketeersapp.com/how-many-cpu-cores-on-ubuntu2024-09-02T00:00:00+00:00<![CDATA[How much RAM memory on Ubuntu]]>https://rocketeersapp.com/how-much-memory-on-ubuntu2024-09-02T00:00:00+00:00<![CDATA[Import MySQL database without timezone difference]]>https://rocketeersapp.com/mysql-import-without-timezone-difference2024-05-02T00:00:00+00:00<![CDATA[Zero downtime deployments using PHP-FPM and nginx]]>https://rocketeersapp.com/zero-downtime-php-deployments2024-10-08T00:00:00+00:00<![CDATA[Environment variables in Laravel]]>https://rocketeersapp.com/environment-variables-laravel
A common misconception is that the passwords in your user table are also relying on the `APP_KEY`. This is not the case!
>
> Passwords are hashed values and are never meant to be un-hashed. Validating a password relies on the hashing algorithm (for Laravel bcrypt is the default driver) and the `APP_KEY` is only used for encrypting and decrypting.
To change your Laravel app's configuration per environment, you can use the `.env` file (derived from `.env.example`) included in every Laravel project. But this does not list all possible `env` variables. So here's a complete list with all default environment variables.
## List of all environment variables
```bash
APP_DEBUG
APP_ENV
APP_FAKER_LOCALE
APP_FALLBACK_LOCALE
APP_KEY
APP_LOCALE
APP_MAINTENANCE_DRIVER
APP_MAINTENANCE_STORE
APP_NAME
APP_PREVIOUS_KEYS
APP_TIMEZONE
APP_URL
AUTH_GUARD
AUTH_MODEL
AUTH_PASSWORD_BROKER
AUTH_PASSWORD_RESET_TOKEN_TABLE
AUTH_PASSWORD_TIMEOUT
AWS_ACCESS_KEY_ID
AWS_BUCKET
AWS_DEFAULT_REGION
AWS_ENDPOINT
AWS_SECRET_ACCESS_KEY
AWS_URL
AWS_USE_PATH_STYLE_ENDPOINT
BEANSTALKD_QUEUE
BEANSTALKD_QUEUE_HOST
BEANSTALKD_QUEUE_RETRY_AFTER
CACHE_STORE
DB_CACHE_CONNECTION
DB_CACHE_LOCK_CONNECTION
DB_CACHE_TABLE
DB_CHARSET
DB_COLLATION
DB_CONNECTION
DB_DATABASE
DB_ENCRYPT
DB_FOREIGN_KEYS
DB_HOST
DB_PASSWORD
DB_PORT
DB_QUEUE
DB_QUEUE_CONNECTION
DB_QUEUE_RETRY_AFTER
DB_QUEUE_TABLE
DB_SOCKET
DB_TRUST_SERVER_CERTIFICATE
DB_URL
DB_USERNAME
DYNAMODB_CACHE_TABLE
DYNAMODB_ENDPOINT
FILESYSTEM_DISK
LOG_CHANNEL
LOG_DAILY_DAYS
LOG_DEPRECATIONS_CHANNEL
LOG_DEPRECATIONS_TRACE
LOG_LEVEL
LOG_PAPERTRAIL_HANDLER
LOG_SLACK_EMOJI
LOG_SLACK_USERNAME
LOG_SLACK_WEBHOOK_URL
LOG_STACK
LOG_STDERR_FORMATTER
LOG_SYSLOG_FACILITY
MAIL_EHLO_DOMAIN
MAIL_ENCRYPTION
MAIL_FROM_ADDRESS
MAIL_FROM_NAME
MAIL_HOST
MAIL_LOG_CHANNEL
MAIL_MAILER
MAIL_PASSWORD
MAIL_PORT
MAIL_SENDMAIL_PATH
MAIL_URL
MAIL_USERNAME
MEMCACHED_HOST
MEMCACHED_PERSISTENT_ID
MEMCACHED_USERNAME
MEMCACHED_PASSWORD
MEMCACHED_PORT
MYSQL_ATTR_SSL_CA
PAPERTRAIL_PORT
PAPERTRAIL_URL
POSTMARK_MESSAGE_STREAM_ID
POSTMARK_TOKEN
QUEUE_CONNECTION
QUEUE_FAILED_DRIVER
REDIS_CACHE_CONNECTION
REDIS_CACHE_DB
REDIS_CACHE_LOCK_CONNECTION
REDIS_CLIENT
REDIS_CLUSTER
REDIS_DB
REDIS_HOST
REDIS_PASSWORD
REDIS_PORT
REDIS_QUEUE
REDIS_QUEUE_CONNECTION
REDIS_QUEUE_RETRY_AFTER
REDIS_URL
REDIS_USERNAME
SESSION_CONNECTION
SESSION_DOMAIN
SESSION_DRIVER
SESSION_ENCRYPT
SESSION_EXPIRE_ON_CLOSE
SESSION_HTTP_ONLY
SESSION_LIFETIME
SESSION_PARTITIONED_COOKIE
SESSION_PATH
SESSION_SAME_SITE
SESSION_SECURE_COOKIE
SESSION_STORE
SESSION_TABLE
SLACK_BOT_USER_DEFAULT_CHANNEL
SLACK_BOT_USER_OAUTH_TOKEN
SQS_PREFIX
SQS_QUEUE
SQS_SUFFIX
```]]>
2024-03-13T00:00:00+00:00<![CDATA[419 Page Expired error in Laravel]]>https://rocketeersapp.com/419-page-expired-laravel2024-09-18T15:36:55+00:00<![CDATA[How to clear cache in Laravel]]>https://rocketeersapp.com/clear-cache-laravel
flush(); # clear cache for 'memcached' store
```
## Framework cache
Laravel has multiple ways to improve its performance by caching framework specific functionality. Here are all caches Laravel uses to bootstrap the framework as quickly as possible:
### Config cache
Using `php artisan config:cache` during deployments, Laravel can optimize config files and make them as static as possble to quickly load the config on each request. This also means you cannot update config dynamically anymore using the helper `config([])`. You can clear the config cache using:
```php
php artisan config:clear
```
### Events cache
Using `php artisan events:cache` when deploying, Laravel can collect all event files upfront, which makes loading of a lot of scatered events inside your application much faster.
```php
php artisan events:clear
```
### Routes cache
To further optimize performance, you can use `php artisan routes:cache` to deploy your Laravel app with an optimized routes cache. This collects all registered routes and creates a static cache to match every route as fast as possible.
Clearing the routes cache:
```php
php artisan routes:clear
```
### Views cache
Laravel compiles the Blade syntax to PHP code when executing the views for rendering it in your application. This cache is stored in `storage/framework/views` and contains all Blade views compiled to PHP files.
Clearing this cache can be done with:
```php
php artisan views:clear
```
## Use Laravel without cache
## Array or null cache driver
To really have no cache at all, you can configure `array` or `null` as cache driver. So this means you have no store at all, only during the runtime of a request the cache will work. After each request the cache will be empty again.
```bash
CACHE_DRIVER=null # or "array"
```]]>
2024-02-15T00:00:00+00:00<![CDATA[How to check Ubuntu version]]>https://rocketeersapp.com/ubuntu-version2024-02-08T00:00:00+00:00<![CDATA[413 Request Entity Too Large in nginx]]>https://rocketeersapp.com/413-request-entity-too-large2024-09-18T15:35:52+00:00<![CDATA[Configure Content Security Policy with nonce using nginx]]>https://rocketeersapp.com/content-security-policy
&1 | tr ' ' '\n' | grep -qi 'http_sub_module' && echo "installed" || echo "not installed"
```
If the module is present, the ouput of the command above will be `installed`.
## Configuring nginx
### We need a nonce
A nonce should be a lenghty random string and therefore unique for each request. In nginx we could create a variable containing a unique random string, but this ends up installing extensions to be able to do so. So instead we use the SSL session ID as a nonce. This is a unique string for each request and is already available in nginx. Fortunately the session ID contains only characters that are allowed in a nonce.
```bash
set $cspNonce $ssl_session_id;
```
### Injecting the nonce into the response
Now we have a nonce, we need to inject it into the responses that nginx serves:
```bash
sub_filter_once off;
sub_filter_types *;
sub_filter NGINX_CSP_NONCE $cspNonce;
```
Here we use `NGINX_CSP_NONCE` as the placeholder for the nonce. This placeholder can be used in the output of your application, and as long it goes through nginx, it will be replaced with a fresh and unique nonce:
```html
```
### Sending the nonce with the CSP headers
Now to apply the nonce to the CSP headers sent by nginx to the client, we can use the `add_header` directive:
```bash
add_header Content-Security-Policy "default-src 'self'; script-src 'self' 'nonce-$cspNonce'; style-src 'self' 'nonce-$cspNonce' always";
```
This CSP policy indicates that every source should come from the same domain as the page itself. The scripts and stylesheets should also contain the nonce that was generated for this request, to verify that only scripts and styles are loaded that are meant to load.
That's it, now you have a CSP policy that is unique for each request and is compatible with full static caching. There are a lot more options to configure CSP, but this is the basic setup. More rules can be found at [Content Security Policy (CSP) Quick Reference Guide](https://content-security-policy.com/).]]>
2024-01-21T00:00:00+00:00<![CDATA[Server Side Includes (SSI) in nginx]]>https://rocketeersapp.com/server-side-includes-ssi-nginx
```
2. Date and Time Stamps: You can insert the current date and time into your web pages.
```html
```
3. Conditional Statements: SSI supports simple conditional statements, allowing you to include or exclude content based on certain conditions.
```html
Content for query string 1.
Content for other cases.
```
4. Variable Setting and Displaying: You can set variables and display their values.
```html
<!--#echo var="pageTitle" -->
```
To use SSI, your web server needs to be configured to recognize and process SSI directives. The file extension ".shtml" is often associated with SSI-enabled files, but the configuration can vary depending on the server software being used (e.g., Apache, nginx). Make sure that the server administrator has enabled SSI processing for the desired file extensions.
## When can SSI be useful?
While including files into another file is a typical task for dynamic scripting languages, there are some situations that SSI is comes in handy. The following situations suit SSI very well:
1. Hosting environment where scripting languages poses a security problem
2. The hosting can't be configured for executing server side scripting
3. When the file that needs to have includes is a static (HTML) file
4. The server resources are limited; SSI is very performant at high traffic
5. It is straightforward, lightweight and makes HTML a little bit dynamic
6. You have no excuses anymore for an outdated copyright year number in the footer
## How to enable SSI in nginx
### Add nginx apt repository
```bash
echo "deb http://nginx.org/packages/ubuntu/ $(lsb_release -sc) nginx
deb-src http://nginx.org/packages/ubuntu/ $(lsb_release -sc) nginx" > /etc/apt/sources.list.d/nginx.list
sudo curl -L https://nginx.org/keys/nginx_signing.key | sudo apt-key add -
sudo apt-get update
```
### Install nginx using nginx-full
```bash
sudo apt install -y nginx-full
```
### Configure SSI
Add in the location block that needs to use SSI, the following rule:
```bash
location / {
...
ssi on;
...
}
```
### Reload nginx service
Reload the nginx service to apply the configuration changes without downtime:
```bash
sudo service nginx reload
```]]>
2023-12-07T00:00:00+00:00<![CDATA[How to install PostgreSQL with pgvector on Ubuntu]]>https://rocketeersapp.com/install-postgresql-pgvector-ubuntu2025-01-06T00:00:00+00:00<![CDATA[How to install Composer packages locally]]>https://rocketeersapp.com/install-composer-packages-locally2023-11-18T00:00:00+00:00<![CDATA[Complete list of Laravel events]]>https://rocketeersapp.com/laravel-events2024-02-15T00:00:00+00:00<![CDATA[Error in the HTTP2 framing layer]]>https://rocketeersapp.com/error-in-the-http2-framing-layer2023-09-04T00:00:00+00:00<![CDATA[Laravel Valet]]>https://rocketeersapp.com/laravel-valet2023-04-26T00:00:00+00:00<![CDATA[Install PHP memcached extension on macOS]]>https://rocketeersapp.com/install-php-memcached-extension-on-macos2023-03-17T00:00:00+00:00<![CDATA[Creating an encrypted cookie value in Laravel]]>https://rocketeersapp.com/creating-an-encrypted-cookie-value-in-laravel
encrypt(
CookieValuePrefix::create($name, $encrypter->getKey()).$value,
false
);
}
}
```]]>
2023-03-08T00:00:00+00:00<![CDATA[How to upgrade MySQL 5.7 to 8.0 on Ubuntu]]>https://rocketeersapp.com/upgrade-mysql-5-7-to-8-0-ubuntu2023-01-12T00:00:00+00:00<![CDATA[Backup MySQL databases in separate files]]>https://rocketeersapp.com/backup-mysql-databases-separate-files
./$DATABASE.sql
done
```
## How to use
You can use this by copying the script, save it in an `backup.sh` file and then execute `chmod +x ./backup.sh` to give the file execution permissions.
Execute the script with `./backup.sh`.]]>
2023-01-12T00:00:00+00:00<![CDATA[Backup MySQL databases in single file]]>https://rocketeersapp.com/backup-mysql-databases-single-file
./databases.sql
```
## How to use
You can use this by copying the script, save it in an `backup.sh` file and then execute `chmod +x ./backup.sh` to give the file execution permissions.
Execute the script with `./backup.sh`.]]>
2024-09-18T15:38:08+00:00<![CDATA[Backup MySQL databases except system databases in a single file]]>https://rocketeersapp.com/backup-mysql-databases-except-system
./databases.sql
```
## How to use
You can use this by copying the script, save it in an `backup.sh` file and then execute `chmod +x ./backup.sh` to give the file execution permissions.
Execute the script with `./backup.sh`.]]>
2024-09-18T15:17:39+00:00<![CDATA[Best practices for sending email]]>https://rocketeersapp.com/best-practices-sending-email
` and `` tags from the email.
It's best to automate the inlining of styles in your code, just before sending the email. So you can still develop the email like you would using stylesheets and CSS selectors. This can be done using an [open source package for inlining CSS](https://github.com/topics/inline-css).
Doing this manually is also an option, you can copy and paste your HTML in [this tool from Mailchimp](https://templates.mailchimp.com/resources/inline-css/) and it converts your HTML and separate CSS selectors to HTML with inline style attributes.
## Create bulletproof buttons
[Buttons.cm](https://buttons.cm) is an indispensable tool when creating buttons for your emails. This tool provides all the necessary legacy code that is needed for all of the different variaty of Microsoft Outlook versions.
## Compatible background images
Background images are another crazy difficult thing to achieve across email clients, also for this special feature you can use a HTML generator that creates cross compatible [image backgrounds in emails](https://backgrounds.cm).
## Write a decent subject line
If you don't want to send your emails straight to the junk folder of your users, be thoughtful with what you put in the subject line of your emails. If you use sketchy phrases like _free_, _buy_ or _now !!!_ than you will end up in the spam because this is what spammers also use to trigger the attention of people.
## Add a preheader text
A lot of email clients show an intro text right below the subject line to preview some of the contents of an email. This way the reader gets more information about what's inside the email. When you don't add a preheader text, the email client can show some random piece of text inside your email message which is not very professional looking.
Using this snippet of HTML, you can add the intro text carefully inside the `
` to only be shown as a preheader text and not inside the email itself:
```html
```
## Add an unsubscribe link
If your sending email more than once, make sure you add a link for the recipient to unsubscribe from your emails. Because nobody that wants to receive your email, should receive your email and it's better to not have them on your list anymore. Big numbers aren't everything and you probably get more reliably sending statistics and better open rates because of this.]]>
2024-09-18T15:35:31+00:00<![CDATA[Improving email deliverability]]>https://rocketeersapp.com/improving-email-deliverability2022-12-06T00:00:00+00:00<![CDATA[How to optimize web application security]]>https://rocketeersapp.com/optimize-web-application-security
`, ``, `