<?xml version="1.0" encoding="UTF-8"?>
<?xml-stylesheet href="/vendor/feed/atom.xsl" type="text/xsl"?>
<feed xmlns="http://www.w3.org/2005/Atom" xml:lang="en-US">
                        <id>https://laravel.io/index.php/forum/feed</id>
                                <link href="https://laravel.io/index.php/forum/feed" rel="self"></link>
                                <title><![CDATA[Laravel.io Forum RSS Feed]]></title>
                    
                                <subtitle>The RSS feed for the Laravel.io forum contains a list of all threads posted by community members.</subtitle>
                                                    <updated>2026-07-10T23:04:05+00:00</updated>
                        <entry>
            <title><![CDATA[Released Laravel Cooldown: A Driver-Based Cooldown Manager]]></title>
            <link rel="alternate" href="https://laravel.io/index.php/forum/released-laravel-cooldown-a-driver-based-cooldown-manager" />
            <id>https://laravel.io/index.php/30843</id>
            <author>
                <name><![CDATA[Mahedi Zaman Zaber]]></name>
            </author>
            <summary type="html">
                <![CDATA[Hi everyone! 👋

I've just open-sourced **Laravel Cooldown**, a package for managing **action cooldowns** in Laravel.

While Laravel's built-in `RateLimiter` is excellent for request throttling, I found myself repeatedly needing a reusable solution for **time-based action restrictions**, such as:

* Password reset requests
* Email verification
* OTP / SMS sending
* AI prompt generation
* Report exports
* Payment retries
* Reward claiming
* Other workflow-based cooldowns

My goals were to make it:

* Driver-based (Cache & Database)
* Easy to attach to Eloquent models
* Middleware-friendly
* Extensible with custom storage drivers
* Pleasant to use through a fluent API

Example:

```php
Cooldown::for('password_reset', $user)->enforce();

// Perform the action...

Cooldown::for('password_reset', $user)->for(300);
```

Some features include:

* Cache & Database drivers
* Native Eloquent integration (`HasCooldowns`)
* Route middleware
* Success-only cooldown triggering (only starts after successful 2xx/3xx responses)
* Immutable DTOs
* Event dispatching
* Automatic database pruning
* Custom driver support via `Cooldown::extend()`

One design decision I'm particularly interested in feedback on is the middleware behavior. Instead of starting the cooldown before the request executes, it only creates the cooldown after a successful response. That way, validation errors or failed requests don't unnecessarily lock users out.

I'd really appreciate any feedback on the API, architecture, naming, or overall developer experience. Suggestions for additional drivers or features are also very welcome.

Repository:
https://github.com/zaber-dev/laravel-cooldown

Thanks!]]>
            </summary>
                                    <updated>2026-07-10T23:04:05+00:00</updated>
        </entry>
            <entry>
            <title><![CDATA[Laravel Forge Is Worth It: A Developer's Personal Experience]]></title>
            <link rel="alternate" href="https://laravel.io/index.php/forum/laravel-forge-is-worth-it-a-developers-personal-experience" />
            <id>https://laravel.io/index.php/30842</id>
            <author>
                <name><![CDATA[Elsie Raine]]></name>
            </author>
            <summary type="html">
                <![CDATA[It's 2 AM, your client's e-commerce site just crashed during a flash sale, and you're staring at a server dashboard that looks like it was designed by someone who's never had to fix anything under pressure. If you've ever manually configured Nginx, wrestled with SSL certificates at the worst possible moment, or lost a weekend to a deployment script that silently failed, you already know the real question isn't "what is Laravel Forge," it's "will this actually save me from doing that again?" I've asked myself that same thing more times than I'd like to admit, and after using Forge across dozens of projects (some tiny, some genuinely terrifying in scale), I want to walk you through what I found, warts and all.

## Why I Even Looked at Forge in the First Place
Before Forge, my server management routine looked like this: SSH into a box, install PHP extensions one by one, configure a queue worker, forget to set up a cron job for scheduled tasks, and then spend an afternoon debugging why my app worked locally but not in production. It wasn't that I didn't know how to do DevOps; it was that doing it manually, every single time, for every single client project, was eating up hours I could have spent actually writing code.

That's the honest reason a lot of developers end up here. It's not laziness. It's math. If server setup takes four hours and you do it fifteen times a year, that's sixty hours gone that could go toward the actual work clients are paying for.

## What Forge Actually Does Differently
[Laravel Forge](https://laravel.com/forge) isn't magic, and I want to be upfront about that. It's a server management panel that connects to your cloud provider (DigitalOcean, AWS, Linode, Vultr, take your pick) and automates the boring, error-prone parts of provisioning a server: installing Nginx, PHP, MySQL, Redis, setting up SSL through Let's Encrypt, and configuring deployment scripts.

The first time I provisioned a server through Forge, it took about eight minutes. Eight minutes for something that used to take half a day. That alone got my attention, but what actually kept me using it was the deployment workflow. You connect your Git repository, define a deployment script, and, from that point forward, pushing to your main branch automatically triggers a zero-downtime deployment. No more manually pulling code, running migrations, and restarting queue workers by hand.

## Where It Genuinely Helped My Workflow
* **Server provisioning stopped being a chore:** I used to dread setting up a new environment for a client. Now it's something I don't think twice about.
* **Queue and scheduler management got simple:** Laravel apps often rely on queues and the scheduler for background jobs, sending emails, processing payments, and generating reports. Forge gives you a clean interface to manage these without editing crontab files or supervisor configs by hand, which used to be a common source of silent failures.
* **SSL just works:** Let's Encrypt integration means I stopped manually renewing certificates or troubleshooting mixed-content warnings because someone forgot to force HTTPS.
* **It scales with the project:** Whether I was building a small internal tool or working alongside a team offering full [Laravel development services](https://wpwebinfotech.com/laravel-development/) to enterprise clients, Forge adapted without forcing me to relearn a new system for bigger workloads. That consistency matters more than people realize until they've had to switch tools mid-project.

## Where It Didn't Solve Everything
I'd be doing you a disservice if I pretended Forge was flawless. A few honest gripes:
* It doesn't replace understanding server administration. If something goes wrong at a deeper level, a misconfigured firewall rule, a memory leak, or a database that needs real tuning, you still need to know Linux and MySQL fundamentals. Forge automates the setup, not the expertise.
* Cost adds up. It's a paid tool on top of whatever you're already paying your cloud provider. For solo developers on tight budgets, that's a real consideration, not a footnote.
* Multi-server setups (load balancers, separate database servers) have a learning curve of their own, even with Forge's help.

None of these are dealbreakers for me, but they're the kind of thing nobody mentions in a five-star review, and I think you deserve the full picture before deciding.

## Was It Actually Worth It?
For my own work, yes, clearly. The time I saved by not manually configuring servers went directly into things clients actually care about: features, bug fixes, and performance improvements. But "worth it" is relative to what you're doing. If you manage one personal project a year, you might not need it. If you're regularly spinning up environments, managing multiple client sites, or working as part of a team delivering ongoing Laravel development services, the math tips heavily in Forge's favor pretty fast.

What convinced me wasn't a single big moment. It was the accumulation of small frustrations that just stopped happening: the SSL renewal I didn't have to think about, the deployment that didn't require me to babysit it, the queue worker that restarted itself without a 2 AM phone call. That's not flashy, but it's the kind of reliability that actually changes how you work day to day.

## Final Thoughts
Laravel Forge won't write your code for you, and it won't turn a bad architecture into a good one. What it does is remove a layer of repetitive, error-prone server work that used to sit between "I wrote the feature" and "the feature is live and working." If you've felt that friction yourself, the dread of a new deployment, the fear of an [SSL certificate](https://www.cloudflare.com/learning/ssl/what-is-an-ssl-certificate/) expiring unnoticed, it's worth trying on a real project rather than just reading about it. Some tools you understand only once you've used them under actual pressure, and Forge is one of them.

## Frequently Asked Questions
### Is Laravel Forge only useful for Laravel projects?
No. While it's built by the Laravel team and optimized for Laravel apps, Forge can provision and manage servers for any PHP application, as well as some non-PHP workloads with manual configuration. The deployment and queue tooling is most seamless with Laravel specifically, though.
### Do I still need to know server administration if I use Forge?
Yes, at least at a basic level. Forge handles provisioning and common configuration tasks, but troubleshooting deeper server issues, security hardening, or performance tuning still requires understanding how Linux servers actually work.
### How much does Laravel Forge cost compared to managing servers manually?
Forge charges a monthly subscription on top of your cloud hosting bill. The cost is usually offset by the hours saved on manual provisioning and deployment, especially if you manage more than a couple of projects, but for a single small site, the savings are less dramatic.
### Can Laravel Forge work with any cloud hosting provider?
It integrates directly with several major providers like DigitalOcean, AWS, Linode, and Vultr, plus it supports connecting to any custom server via SSH if your provider isn't natively listed.
### Is Forge a good fit for freelancers or small teams, or only large companies?
It works well for both. Freelancers benefit from the time saved on repetitive setup tasks, while small teams and agencies find the standardized deployment process helps maintain consistency across multiple client projects without extra overhead.]]>
            </summary>
                                    <updated>2026-07-10T23:04:05+00:00</updated>
        </entry>
            <entry>
            <title><![CDATA[Open-Source Textile ERP Built with Next.js 16]]></title>
            <link rel="alternate" href="https://laravel.io/index.php/forum/open-source-textile-erp-built-with-nextjs-16" />
            <id>https://laravel.io/index.php/30841</id>
            <author>
                <name><![CDATA[Imran Dev BD]]></name>
            </author>
            <summary type="html">
                <![CDATA[Hey everyone,

I recently built an open-source Textile ERP system and wanted to share it with the community here. While this is built entirely in the Next.js ecosystem, I know a lot of us use React/Next.js alongside our typical backend stacks, so I thought it might be of interest or serve as a good frontend architecture reference!

It's designed to handle standard ERP operations tailored specifically for the textile industry. 

**The Tech Stack:**
*   **Framework:** Next.js 16
*   **Styling:** Tailwind CSS
*   **Database/ORM:** Prisma

**Repository:**
https://github.com/imranbru99/textile-erp-nextjs

I would love for you to check it out. Feedback, code reviews, and PRs are more than welcome. If you find it useful or interesting as a reference for your own full-stack projects, a star on the repo would be highly appreciated. 

Let me know what you think of the structure or if you have any suggestions for improvement!]]>
            </summary>
                                    <updated>2026-07-10T23:04:05+00:00</updated>
        </entry>
            <entry>
            <title><![CDATA[I built an Eloquent-style ORM for Node.js]]></title>
            <link rel="alternate" href="https://laravel.io/index.php/forum/i-built-an-eloquent-style-orm-for-nodejs" />
            <id>https://laravel.io/index.php/30840</id>
            <author>
                <name><![CDATA[Raphael Abayomi]]></name>
            </author>
            <summary type="html">
                <![CDATA[Been writing Laravel for years. Every time a project pulls me into Node.js territory, whether it's a side project, a microservice, or just helping a team, the first thing I notice is that nothing feels like Eloquent.

Prisma is fine but it's a different mental model entirely. TypeORM is verbose. Drizzle is SQL-first in a way that's almost too raw. None of them have scopes, observers, morph relationships, or that clean fluent API that just *clicks* once you know it.

So I built one.

It's called **IlanaORM** (`ilana-orm` on npm). It runs on Node.js and TypeScript, built on Knex.js under the hood, and the API is as close to Eloquent as I could get it.

Here's what the same pattern looks like side by side:

**Laravel Eloquent:**
```php
$posts = Post::published()
    ->with('author')
    ->orderBy('created_at', 'desc')
    ->get();
```

**IlanaORM:**
```ts
const posts = await Post.query()
  .published()
  .with('author')
  .orderBy('created_at', 'desc')
  .get();
```

Scopes work exactly the same way. Define them on the model, chain them on queries. Relationships (`hasOne`, `hasMany`, `belongsTo`, `belongsToMany`, `morphTo`, `morphMany`, `hasManyThrough`) all work. Soft deletes, casting, events, observers, global scopes, factories, seeders, migrations, all in there.

A few things beyond standard Eloquent:

- **ULID and UUID primary keys** supported (opt-in)
- **pgvector support** built in for AI/embedding search
- **Edge runtime support** (Cloudflare Workers, Next.js edge routes)
- Supports MySQL, PostgreSQL, SQLite, and Supabase
- No code generation step

It is live now. Docs are at https://raphwebb.mintlify.com and the package is `npm install ilana-orm`.

GitHub: https://github.com/raphyabak/ilana-orm

Genuinely curious what you all think, especially if you've worked in both Laravel and Node.js and felt the same frustration. Happy to hear what's missing or what I got wrong.]]>
            </summary>
                                    <updated>2026-07-10T23:04:05+00:00</updated>
        </entry>
            <entry>
            <title><![CDATA[Anti-Swagger]]></title>
            <link rel="alternate" href="https://laravel.io/index.php/forum/anti-swagger" />
            <id>https://laravel.io/index.php/30805</id>
            <author>
                <name><![CDATA[Myat Kyaw Thu]]></name>
            </author>
            <summary type="html">
                <![CDATA[If you’re a **Laravel developer**, you know the pain: you finish a feature, but then you spend another 30 minutes updating YAML files or adding messy docblock annotations just so the frontend team knows how the API works.

I built **Laravel API Visibility** to change that. No annotations, no configuration, and zero manual work.
What it does:
✅ Automatic Documentation: Scans your routes and controllers instantly.
✅ Static Analysis: Uses PHP Reflection to "read" your code and predict responses without even running an HTTP request.
✅ Postman Export: One click to generate a full Postman collection, pre-wired with headers and auth.
✅ FormRequest Support: Automatically detects your validation rules and generates example payloads.

It’s lightweight, dark-mode friendly, and stays out of your production environment by default.

Check it out on GitHub: https://github.com/myat-kyaw-thu/laravel-api-visibility

I'd love to hear what the Laravel community thinks!]]>
            </summary>
                                    <updated>2026-07-10T23:04:05+00:00</updated>
        </entry>
            <entry>
            <title><![CDATA[What are the Essential Software Engineer Skills in 2026?]]></title>
            <link rel="alternate" href="https://laravel.io/index.php/forum/what-are-the-essential-software-engineer-skills-in-2026" />
            <id>https://laravel.io/index.php/30839</id>
            <author>
                <name><![CDATA[kapilsharma]]></name>
            </author>
            <summary type="html">
                <![CDATA[### Introduction
Software engineering roles and responsibilities have changed. Well, the skills that were relevant five years ago are not enough today. Because companies are looking for engineers who can perform more than just writing the code. They want people who understand testing, automation, cloud, and teamwork all at once. 

For the people who are looking to grow their career as a Software engineer, it is the right time to enter this field by taking [Software Testing Online Course](https://www.cromacampus.com/courses/software-testing-online-training/). In this article, we have discussed the essential skills that one should have in the year 2026 to get a job. From the day AI introduced many of the companies are preferring employees with AI knowledge and implementing it in practice. So, let’s begin discussing this in detail:

### Essential Software Engineer Skills in 2026:

### 1. Core Programming Skills
Before you go through anything else, you need to have a strong foundation of writing code. So you need to have an understanding of why certain code slows down everything. So you need to know how to structure the program so it does not fall apart when someone else interrupts it. 

Most of the engineers choose one language and go deep. So some of the languages, such as Python, Java, and JavaScript, are all good choices. This language matters less than how well you know it.

### 2. Software Testing Knowledge
Most engineers do not want to deal with testing. They write the code and move on. Someone else can check if it works. That attitude was common for a long time. These days it does not fly.

Companies now expect you to test what you build. Not someone else. You. If you do not know the difference between a unit test and an integration test, that is a problem in most interviews and most jobs.

A Software Testing Online Course helps you get this right from the start. You learn what each type of test does and when it actually makes sense to use it. That practical understanding matters more than just knowing the terms.

### 3. Automation Testing
Testing the same thing by hand every time a change is made gets old fast. That is why automation exists. You write a script once and it runs the check every time without you doing anything.

Most teams already work this way. If you show up not knowing any automation tools, you are starting from behind. Selenium, Cypress, and Playwright are the names you will hear constantly. Getting hands-on with them through an [Automation Software Testing Course](https://www.cromacampus.com/courses/automation-software-testing-course/) is the fastest way to get up to speed. You build real scripts, you make real mistakes, and you come out of it with something to show.

### 4. Working in Agile Teams
Agile is how most software teams are organized. There are short work cycles called sprints. There are daily check-ins. There are planning meetings at the start and review sessions at the end.

Some engineers hate this structure. They find it distracting. But fighting it does not change anything; it just makes you difficult to work with. The engineers who learn to work inside this system, give honest estimates, and raise problems early are the ones manager’s trust. That trust leads to better projects and faster growth.

### 5. CI/CD Pipelines
Pushing the code was all about someone manually copying the files to the server and hoping that nothing will break. But it was too slow, stressful and broke constantly. CI/CD helped in replacing it.

So from the next time when you may push the code, update if everything is passed. You may need not to keep a watch on the same. GitHub Actions and Jenkins are two tools you will run into often.

You may need not to set everything from scratch on your first day. But you need to have an idea of how they work. When a pipeline get failed you have to read the output and understand what has happened. That is a basic expectation at most companies now.

### 6. Debugging
This is the skill nobody really teaches but everyone needs badly. More working hours go into fixing broken code than writing new code. That is just the reality.

Getting better at debugging is not about reading more. It is about doing it more. Every bug you fix teaches you something the next one will be faster to solve.

### ●	Why Take a Course in Bangalore?
Going through [Software Testing Classes in Bangalore](https://www.cromacampus.com/courses/software-testing-course-in-bangalore/) helps with this more than most people expect. When you understand how tests catch failures, you start seeing where your own code is likely to go wrong before it does. That changes how you write and how fast you fix things.

### 7. Written Communication
This is the skill engineers are most surprised to need.

You can write great code and still cause problems if nobody can understand your notes, your comments, or your messages. A pull request with no description makes extra work for whoever reviews it. A vague message about a blocker delays the whole team.

You do not need to be a writer. You just need to be clear. Say what you did. Say why. Say what you need. Keep it short. That is genuinely all it takes, and it makes a real difference in how people see your work.

### Conclusion
You don’t need to work on all skills at the same time. Well, you can begin with the ones closest to where you are currently. So taking the Software Testing Online Course is a good investment of your time. It builds the foundation that makes skills two, three, and eight a lot easier to develop. The engineers who are doing well are the ones who are reliable, clear, and cover their bases.]]>
            </summary>
                                    <updated>2026-07-10T23:04:05+00:00</updated>
        </entry>
            <entry>
            <title><![CDATA[Can you share some real websites using Laravel]]></title>
            <link rel="alternate" href="https://laravel.io/index.php/forum/can-you-share-some-real-websites-using-laravel" />
            <id>https://laravel.io/index.php/30798</id>
            <author>
                <name><![CDATA[Serena]]></name>
            </author>
            <summary type="html">
                <![CDATA[Hi Guys,

Good day! 

Can you share some real websites using Laravel? 

And If I have a website, how do I know if there's any tags or signs that shows it's using Laravel? AI tells me to check like this document.cookie.includes('laravel_session')  to see if such a cookie...is that true?

Thanks:)]]>
            </summary>
                                    <updated>2026-07-10T23:04:05+00:00</updated>
        </entry>
            <entry>
            <title><![CDATA[Live Browser Updates for Blade Without Livewire]]></title>
            <link rel="alternate" href="https://laravel.io/index.php/forum/live-browser-updates-for-blade-without-livewire" />
            <id>https://laravel.io/index.php/30838</id>
            <author>
                <name><![CDATA[Vishnu Prasad]]></name>
            </author>
            <summary type="html">
                <![CDATA[Hi everyone,

I've been building **KAAL Realtime**, a Laravel package that enables **live updates across connected browsers** while letting you continue using standard Blade templates.

![](https://camo.githubusercontent.com/6e2dc119929c76753e737a14af94fb8129c55d13c8b54aa16f4a92e2eafd778b/68747470733a2f2f646f63732e6b61616c7265616c74696d652e636f6d2f6173736574732f6c6f676f2f6c6f676f2e706e67)

Instead of converting pages into Livewire components, you wrap the section you want to keep synchronized:

```blade
@realtime([\App\Models\Message::class])
    @include('chat.messages')
@endrealtime
```

When the underlying model changes, every connected browser viewing that page automatically receives the updated HTML fragment over WebSockets. Only the affected section is refreshed—there's no full page reload.

### Features

* Live browser-to-browser updates
* Native Blade support
* No Livewire components required
* Automatic model watching
* Handler mode for complex updates
* Signed fragment requests
* Authentication preserved
* Laravel Reverb integration
* Lightweight JavaScript runtime

For scenarios where updates depend on multiple models or custom business logic, you can also register a custom realtime handler instead of relying on automatic model detection.

Some use cases include:

* Live chat
* Notifications
* Admin dashboards
* Order management
* Inventory updates
* Support dashboards
* Monitoring panels
* Collaborative internal tools

The goal is to bring realtime capabilities to existing Blade applications with minimal changes while preserving the familiar Laravel development experience.

I'd love to hear your thoughts:

* Would you use this in a production Blade application?
* What features or integrations would you like to see?
* Are there any edge cases or performance concerns I should consider?

**Documentation:** https://docs.kaalrealtime.com

**GitHub:** https://github.com/esagono-teq/kaal-realtime.git]]>
            </summary>
                                    <updated>2026-07-10T23:04:05+00:00</updated>
        </entry>
            <entry>
            <title><![CDATA[CarvePHP alpha: service boundaries in Laravel monolithsPacka]]></title>
            <link rel="alternate" href="https://laravel.io/index.php/forum/carvephp-alpha-service-boundaries-in-laravel-monolithspacka" />
            <id>https://laravel.io/index.php/30837</id>
            <author>
                <name><![CDATA[Muhammad Waleed Khalil]]></name>
            </author>
            <summary type="html">
                <![CDATA[Hey everyone,

I recently released the first alpha of **CarvePHP**, an open-source Laravel package for teams working with large Laravel monoliths.

The goal is not automatic “one-click microservices.” I know that is not realistic for most real-world systems.

Instead, CarvePHP focuses on a more practical problem:

**How do you identify possible service boundaries in a Laravel monolith using evidence?**

Current alpha features:

* scans routes, controllers, models, migrations, and database usage
* optionally traces runtime route/table coupling
* builds a dependency graph
* suggests candidate service boundaries
* generates Markdown/JSON migration reports

Install:

```bash
composer require carvephp/carve:^0.1@alpha --dev
```

Basic usage:

```bash
php artisan carve:install
php artisan carve:doctor
php artisan carve:scan --pretty
php artisan carve:analyze
php artisan carve:boundaries --report=carve-boundaries.md
php artisan carve:report --output=carve-report.md
```

GitHub:
https://github.com/Muhammad-Waleed-Khalil/CarvePHP

Packagist:
https://packagist.org/packages/carvephp/carve

It currently supports Laravel 11, 12, and 13.

I’m mainly looking for feedback from Laravel developers who have worked on large monoliths:

* What evidence would you want before trusting a suggested service boundary?
* Which Laravel patterns should the analyzer support first?
* Would graph visualization, better FormRequest analysis, or API Resource analysis be more useful for the next release?

Any feedback, criticism, or real-world edge cases would be appreciated.]]>
            </summary>
                                    <updated>2026-07-10T23:04:05+00:00</updated>
        </entry>
            <entry>
            <title><![CDATA[Laravel Query Filters Package – Clean Eloquent filtering]]></title>
            <link rel="alternate" href="https://laravel.io/index.php/forum/laravel-query-filters-package-clean-eloquent-filtering" />
            <id>https://laravel.io/index.php/30836</id>
            <author>
                <name><![CDATA[Ahmed Ezz]]></name>
            </author>
            <summary type="html">
                <![CDATA[Hey everyone 👋

I built a small Laravel package for filtering Eloquent models via request query strings, and I'd love to get some feedback from the community.

**Package:** https://github.com/AhmedEzz20/laravel-query-filters
**Packagist:** https://packagist.org/packages/dev-astro/laravel-query-filters

---

### What it does

Keeps your controllers clean by moving all filter logic into dedicated filter classes.

```bash
php artisan make:filter BrandFilter
```

```php
class BrandFilter extends BaseFilters
{
    protected array $filters = ['search_name', 'status', 'created_from'];
    protected array $sortable = ['id', 'name', 'created_at'];

    protected function searchName($value)
    {
        return $this->builder->where('name', 'like', "%{$value}%");
    }
}
```

Then in your controller:
```php
Brand::filter()->paginate();
```

---

### Features
- `make:filter` Artisan command
- Auto date range filtering via `_from` / `_to` convention
- Built-in sorting with column whitelist
- `perPage` support from request
- Zero config — works out of the box

Would love any feedback, suggestions, or PRs! 🙏]]>
            </summary>
                                    <updated>2026-07-10T23:04:05+00:00</updated>
        </entry>
            <entry>
            <title><![CDATA[What do you use to compare different versions of text?]]></title>
            <link rel="alternate" href="https://laravel.io/index.php/forum/what-do-you-use-to-compare-different-versions-of-text" />
            <id>https://laravel.io/index.php/30835</id>
            <author>
                <name><![CDATA[Hardik Barvaliya]]></name>
            </author>
            <summary type="html">
                <![CDATA[I often need to compare different versions of documentation, website content, configuration snippets, and notes. Git works great for source code, but for plain text I sometimes find it more convenient to use a dedicated comparison tool.

I'm interested in learning what other developers use for this workflow. Do you rely on editor features, standalone applications, or browser-based tools?

Recently I came across a tool called [Text Differ](https://text-differ.com/) that focuses on comparing two blocks of text and highlighting the changes. It made me wonder what approaches others prefer and which features are most important when reviewing text revisions.

What does your workflow look like?]]>
            </summary>
                                    <updated>2026-07-10T23:04:05+00:00</updated>
        </entry>
            <entry>
            <title><![CDATA[How do you track who really triggered model changes?]]></title>
            <link rel="alternate" href="https://laravel.io/index.php/forum/how-do-you-track-who-really-triggered-model-changes" />
            <id>https://laravel.io/index.php/30834</id>
            <author>
                <name><![CDATA[Roma]]></name>
            </author>
            <summary type="html">
                <![CDATA[Hi everyone,
I’ve been running into an issue in queue-heavy Laravel apps where the real origin of a change gets lost.
Typical flow:
HTTP request → service → queue → job → model update
By the time the model is updated, the audit log usually only shows the job or system as the actor, not the user who originally triggered the action.
So instead of:
“User Roman changed the order”
you often end up with:
“System updated order”
This makes debugging incidents really hard, because you lose the execution context across the queue boundary.
I’m curious how others handle this problem, do you track origin somehow, or just rely on basic audit logs?]]>
            </summary>
                                    <updated>2026-07-10T23:04:05+00:00</updated>
        </entry>
            <entry>
            <title><![CDATA[Pterocos - Browser-based PHP editor for Laravel prototyping]]></title>
            <link rel="alternate" href="https://laravel.io/index.php/forum/pterocos-browser-based-php-editor-for-laravel-prototyping" />
            <id>https://laravel.io/index.php/30833</id>
            <author>
                <name><![CDATA[Amine. KHD]]></name>
            </author>
            <summary type="html">
                <![CDATA[Hey Laravel community!

I built Pterocos (https://pterocos.eu.org) - a free online editor that runs PHP code entirely in your browser. No installation, no account required.

**Why Laravel developers might find this useful:**
- Quickly test PHP snippets without local setup
- Prototype Laravel logic (collections, queries) instantly
- Share runnable examples with teammates or learners

**What Pterocos supports:**
- PHP 🐘
- Also: C#, Rust, Python, Ruby, SQL (SQLite/DuckDB), Lua

The editor runs entirely client-side - your code never leaves your browser.

**Try it:** https://pterocos.eu.org

Would love feedback from the Laravel community!]]>
            </summary>
                                    <updated>2026-07-10T23:04:05+00:00</updated>
        </entry>
            <entry>
            <title><![CDATA[ERP Software Development Company | Enterprise Resource Plann]]></title>
            <link rel="alternate" href="https://laravel.io/index.php/forum/erp-software-development-company-enterprise-resource-plann" />
            <id>https://laravel.io/index.php/30832</id>
            <author>
                <name><![CDATA[jafijanet]]></name>
            </author>
            <summary type="html">
                <![CDATA[As a trusted [](https://www.nxdeep.com/erp-software-development), NxDeep Connectz creates strong and scalable ERP solutions designed for specific business needs. Our ERP systems bring together essential business processes, remove data silos, and improve operational efficiency through centralized management and real-time analytics. We assist organizations with custom ERP development, implementation, integration, and ongoing support. Our goal is to help businesses use resources more effectively, streamline workflows, and boost growth with secure and future-ready ERP software solutions.
![]()]]>
            </summary>
                                    <updated>2026-07-10T23:04:05+00:00</updated>
        </entry>
            <entry>
            <title><![CDATA[Is it correct to use ASSET_URL or forceRootUrl() when behind]]></title>
            <link rel="alternate" href="https://laravel.io/index.php/forum/is-it-correct-to-use-asset-url-or-forcerooturl-when-behind" />
            <id>https://laravel.io/index.php/30829</id>
            <author>
                <name><![CDATA[Tarcísio Santos]]></name>
            </author>
            <summary type="html">
                <![CDATA[I'm using Laravel 13 and accessing my app via ngrok. I noticed that changing APP_URL in my .env file doesn't affect asset() it still generates localhost URLs. After digging in, I found two ways to fix it:

1. Set ASSET_URL to the ngrok URL
2. Add URL::forceRootUrl(config('app.url')) in AppServiceProvider::boot()

Both work, but the docs say ASSET_URL is intended for CDN deployments where assets are on a separate domain. And forceRootUrl() feels heavy since it overrides all URL generation.
My question is: what's the correct approach for a scenario like this (ngrok, or even a real hosting behind a proxy)? Should I always set ASSET_URL alongside APP_URL in these environments, or is forceRootUrl() the intended way to make APP_URL control all generated URLs?]]>
            </summary>
                                    <updated>2026-07-10T23:04:05+00:00</updated>
        </entry>
            <entry>
            <title><![CDATA[Advice/tips on a React application with Laravel backend]]></title>
            <link rel="alternate" href="https://laravel.io/index.php/forum/advicetips-on-a-react-application-with-laravel-backend" />
            <id>https://laravel.io/index.php/30828</id>
            <author>
                <name><![CDATA[Ginus van der Zee]]></name>
            </author>
            <summary type="html">
                <![CDATA[I'm currently working on a personal project related to Warhammer. Because I needed to test some things, I have made an test project for a quiz that would help select a faction. But I'm kind of still looking for advise to improve it. 

At first I had all the faction calculations run on the backend, but I've since moved that to the frontend. I was thinking of expanding the database and have tables with Warhammer units be tied the faction and have the website showcase them.


Github link: https://github.com/GinusHR/ple-content-quiz-test]]>
            </summary>
                                    <updated>2026-07-10T23:04:05+00:00</updated>
        </entry>
            <entry>
            <title><![CDATA[Built a binary approval workflow engine for Laravel]]></title>
            <link rel="alternate" href="https://laravel.io/index.php/forum/built-a-binary-approval-workflow-engine-for-laravel" />
            <id>https://laravel.io/index.php/30826</id>
            <author>
                <name><![CDATA[mema]]></name>
            </author>
            <summary type="html">
                <![CDATA[I’ve been working on internal approval/workflow systems for years and recently tried extracting the core engine into a reusable Laravel package.

Repository:
[Approval Binary GitHub Repository](https://github.com/menma977/Approval-Binary)

The package started as a simple approval system idea but eventually evolved into something closer to a workflow orchestration engine.

Main concepts currently implemented:

sequential & parallel approval
AND / OR contributor logic
dynamic approver resolution
condition-based routing
runtime event snapshots
rollback / force state handling
bigint bitmask approval state

The binary/bitmask idea was inspired by Linux permission concepts to represent partial approval states without relying only on status columns or linear step numbers.

One thing I’m still unsure about is whether this abstraction level still makes sense inside Laravel ecosystem, or if I’m overengineering something that most applications would solve with simpler patterns.

I’d really appreciate feedback from people who have experience with:

approval engines
ERP/internal systems
workflow orchestration
backend-heavy architecture
state modeling

Especially interested in opinions about:

architecture direction
workflow modeling
bitmask state approach
possible edge cases
maintainability concerns

Would love honest criticism.]]>
            </summary>
                                    <updated>2026-07-10T23:04:05+00:00</updated>
        </entry>
            <entry>
            <title><![CDATA[Laravel Tailwind tables (like Yajra, no Livewire)]]></title>
            <link rel="alternate" href="https://laravel.io/index.php/forum/laravel-tailwind-tables-like-yajra-no-livewire" />
            <id>https://laravel.io/index.php/30789</id>
            <author>
                <name><![CDATA[Tarcísio Santos]]></name>
            </author>
            <summary type="html">
                <![CDATA[Good evening, everyone!
I’m looking for recommendations for libraries or packages to create tables in Laravel using Tailwind CSS. Previously, I used Yajra Laravel DataTables with Bootstrap, but now I want to switch to a solution that works well with Tailwind and, preferably, doesn’t rely on Livewire.
Does anyone have suggestions for packages or approaches that can replace Yajra while keeping pagination, sorting, and filtering functionality?
Thanks!]]>
            </summary>
                                    <updated>2026-07-10T23:04:05+00:00</updated>
        </entry>
            <entry>
            <title><![CDATA[Arr::after() — Get the next value in an array with optional]]></title>
            <link rel="alternate" href="https://laravel.io/index.php/forum/arrafter-get-the-next-value-in-an-array-with-optional" />
            <id>https://laravel.io/index.php/30823</id>
            <author>
                <name><![CDATA[Gulfaraz Arshad]]></name>
            </author>
            <summary type="html">
                <![CDATA[Hey everyone! 👋

I recently tried to contribute `Arr::after()` to the Laravel framework 
(PR #60081) but Taylor decided to keep the framework minimal. So I 
released it as a standalone package!

## What it does

Retrieves the value after a given value in an array.

## Installation

```bash
composer require gulfaraz-arshad/laravel-arr-extended
```

## Usage

```php
use GulfarazArshad\LaravelArrExtended\Arr;

// Basic
Arr::after(['a', 'b', 'c'], 'a'); // 'b'

// Returns null when last (default)
Arr::after(['a', 'b', 'c'], 'c'); // null

// Wraps around with flag
Arr::after(['a', 'b', 'c'], 'c', wrap: true); // 'a'

// Works with associative arrays
Arr::after(['x' => 'a', 'y' => 'b'], 'a'); // 'b'
```

## Use Cases
- 🎠 Carousel navigation
- 📋 Step wizards
- ⚖️ Round-robin load balancing
- 📅 Day rotation

📦 Packagist: https://packagist.org/packages/gulfaraz-arshad/laravel-arr-extended
💻 GitHub: https://github.com/gulfaraz-arshad/laravel-arr-extended

Would love to hear your feedback! ⭐]]>
            </summary>
                                    <updated>2026-07-10T23:04:05+00:00</updated>
        </entry>
            <entry>
            <title><![CDATA[Feedback on a lightweight Laravel rule enginepackagesppa]]></title>
            <link rel="alternate" href="https://laravel.io/index.php/forum/feedback-on-a-lightweight-laravel-rule-enginepackagesppa" />
            <id>https://laravel.io/index.php/30819</id>
            <author>
                <name><![CDATA[lei]]></name>
            </author>
            <summary type="html">
                <![CDATA[Hi everyone,

I’ve been working on a small open-source PHP package called RuleFlow PHP:

https://github.com/yl0711-coder/ruleflow-php

It is a lightweight Decision List rule engine for PHP and Laravel applications.

The problem I’m trying to solve is common in business systems: risk checks, content moderation, marketing eligibility, and order review logic often start as simple if/else
blocks, but eventually become scattered across controllers, services, jobs, validators, and domain services.

RuleFlow keeps these business decisions as structured rules that can be:

- reviewed before deployment
- validated with an Artisan command
- tested in PHPUnit
- explained through trace() and explain()
- integrated with Laravel config and cache

It is not trying to be Drools, a RETE engine, a workflow engine, or a visual rule management platform. The goal is much smaller: make medium-sized Laravel business rules more
deterministic, readable, testable, and explainable.

Laravel integration currently includes:

- service provider auto-discovery
- config publishing
- facade support
- Laravel cache store support
- php artisan ruleflow:validate
- compatibility tests for Laravel 10, 11, and 12

I would really appreciate feedback from Laravel developers:

- Does this solve a real problem you have seen in Laravel projects?
- Is the API simple enough?
- Are the examples close to real-world usage?
- What would block you from using something like this in an internal business system?

Thanks.]]>
            </summary>
                                    <updated>2026-07-10T23:04:05+00:00</updated>
        </entry>
    </feed>
