<?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-09-07T21:28:58+00:00</updated>
                        <entry>
            <title><![CDATA[When Does It Make Sense to Replace Postman for Laravel API T]]></title>
            <link rel="alternate" href="https://laravel.io/index.php/forum/when-does-it-make-sense-to-replace-postman-for-laravel-api-t" />
            <id>https://laravel.io/index.php/30889</id>
            <author>
                <name><![CDATA[luc]]></name>
            </author>
            <summary type="html">
                <![CDATA[Postman has been part of my Laravel API workflow for a long time, but lately I’ve been looking for something that fits better with CLI and CI/CD workflows.

For Laravel API projects, I usually want to:

Run API tests from the command line
Manage multiple environments
Reuse the same tests in CI/CD
Keep API documentation updated
Share API workflows between developers and QA

That’s what led me to look at Apidog as a possible Postman alternative.

What I find interesting is that it combines API design, testing, documentation, and CLI automation instead of keeping those workflows separate.

For those building Laravel APIs:

Are you still using Postman?

Have you moved to another tool for API testing?

And how are you handling API tests in your CI/CD pipeline?]]>
            </summary>
                                    <updated>2026-09-07T21:28:58+00:00</updated>
        </entry>
            <entry>
            <title><![CDATA[What Terminal-Based API Testing Tool Do You Use for Laravel?]]></title>
            <link rel="alternate" href="https://laravel.io/index.php/forum/what-terminal-based-api-testing-tool-do-you-use-for-laravel" />
            <id>https://laravel.io/index.php/30856</id>
            <author>
                <name><![CDATA[luc]]></name>
            </author>
            <summary type="html">
                <![CDATA[Most of the Laravel projects I work on expose REST APIs, and I've been trying to move more of my API testing into the terminal instead of relying on a GUI.

The goal is simple: use the same workflow locally and in CI/CD.

I'm looking for a terminal-based API testing tool that can:

*Run API tests from the command line
*Support multiple environments
*Work with OpenAPI-based APIs
*Integrate with GitHub Actions
*Return reliable exit codes for automation

So far I've tried curl, HTTPie, Hurl, Newman, and Apidog CLI.

I've been leaning toward Apidog CLI because I can run the same API test scenarios while developing a Laravel application and then reuse those tests in GitHub Actions without maintaining separate workflows.

For those building API-first Laravel applications:

*What terminal-based API testing tool do you use?
*Have you completely replaced Postman, or do you use both?
*Which tool has been the easiest to integrate into your CI/CD pipeline?]]>
            </summary>
                                    <updated>2026-09-07T21:28:58+00:00</updated>
        </entry>
            <entry>
            <title><![CDATA[How Can Fixer Simplify Currency Conversion?]]></title>
            <link rel="alternate" href="https://laravel.io/index.php/forum/how-can-fixer-simplify-currency-conversion" />
            <id>https://laravel.io/index.php/30886</id>
            <author>
                <name><![CDATA[William hazad]]></name>
            </author>
            <summary type="html">
                <![CDATA[Fixer is a currency exchange API designed to help developers access reliable exchange rate and currency conversion data. It can be integrated into websites, mobile applications, ecommerce platforms, financial dashboards, and other digital products that work with multiple currencies.

With structured currency data available through an API, developers can automate exchange rate retrieval and reduce the need for manually maintained currency information. This can be useful for displaying converted prices, supporting international transactions, creating currency converters, and managing financial calculations across different markets.

Fixer also provides a practical option for businesses and developers looking to build applications that require currency-related data without creating their own exchange rate infrastructure from scratch.

**Get started with Fixer:** https://fixer.io/]]>
            </summary>
                                    <updated>2026-09-07T21:28:58+00:00</updated>
        </entry>
            <entry>
            <title><![CDATA[Why Isn't My Website Ranking for Arabic Keywords?]]></title>
            <link rel="alternate" href="https://laravel.io/index.php/forum/why-isnt-my-website-ranking-for-arabic-keywords" />
            <id>https://laravel.io/index.php/30885</id>
            <author>
                <name><![CDATA[Thomas Shellby]]></name>
            </author>
            <summary type="html">
                <![CDATA[Hi everyone,

I'm trying to figure out why a website that performs well for English searches struggles to gain visibility for Arabic keywords. We've already added Arabic content, but the rankings and organic traffic haven't improved as expected.

I'd love to hear from anyone with experience in multilingual or regional SEO.

A few questions:

Is translating existing content enough, or should Arabic content be written specifically for native speakers?
How much does localized keyword research influence rankings?
Do technical factors like RTL formatting, hreflang implementation, and Arabic-friendly URLs make a noticeable difference?
Are region-specific backlinks important for improving Arabic keyword rankings?
Does Google interpret search intent differently across GCC countries?

If you've managed Arabic SEO campaigns, what changes had the biggest impact on rankings?

I'm particularly interested in understanding what businesses in Dubai are doing differently to compete in Arabic search results and whether investing in a dedicated [arabic SEO services in Dubai](https://burjcode.ae/marketing/arabic-seo-services-dubai/) is worth it.

Looking forward to hearing your experiences and recommendations.

While researching agencies that specialize in Arabic SEO, I came across Burj Code. If anyone has worked with them or knows about their approach, I'd be interested in hearing your feedback.]]>
            </summary>
                                    <updated>2026-09-07T21:28:58+00:00</updated>
        </entry>
            <entry>
            <title><![CDATA[How should Laravel applications handle AI agents that need h]]></title>
            <link rel="alternate" href="https://laravel.io/index.php/forum/how-should-laravel-applications-handle-ai-agents-that-need-h" />
            <id>https://laravel.io/index.php/30884</id>
            <author>
                <name><![CDATA[luc]]></name>
            </author>
            <summary type="html">
                <![CDATA[I've been experimenting with AI-driven workflows in Laravel, and one question keeps coming up: what should happen when an AI agent reaches a step where it shouldn't make the decision on its own?

For example, imagine a queued workflow where an agent:

Receives a task
Analyzes the data
Executes several actions
Reaches a decision requiring human approval
Pauses the workflow
Resumes after the human provides feedback

Laravel already gives us useful building blocks for this with queues, jobs, events, notifications, and scheduled tasks.

The interesting part is combining those pieces with an agent that can maintain its state and continue the workflow after a human intervention.

I've also been exploring this concept from the project-management side with Sharkly, where AI agents can work alongside human teammates and hand tasks back to humans when they need input.

https://sharkly.ai/

For Laravel developers building AI agents, how are you currently handling state, retries, approvals, and human-in-the-loop steps in long-running agent workflows?]]>
            </summary>
                                    <updated>2026-09-07T21:28:58+00:00</updated>
        </entry>
            <entry>
            <title><![CDATA[Good Coding Challenges]]></title>
            <link rel="alternate" href="https://laravel.io/index.php/forum/good-coding-challenges" />
            <id>https://laravel.io/index.php/30883</id>
            <author>
                <name><![CDATA[Thomas Shellby]]></name>
            </author>
            <summary type="html">
                <![CDATA[Every developer faces problems that look easy at first but turn into hours of debugging, research, and experimentation. Sometimes it’s a frustrating bug, sometimes it’s understanding a new framework, improving application performance, fixing an unexpected edge case, or simply figuring out why something refuses to work.

But these challenges often become the experiences that help us grow the most.

So, let’s discuss:

What’s one coding challenge you’ve faced that genuinely improved your development skills?

What were you working on, and what made the problem difficult? How did you approach it? Did you rely on documentation, Stack Overflow, GitHub, AI tools, your teammates, or good old-fashioned trial and error?

More importantly, what did you learn from the experience?

Whether you’re a beginner who recently solved your first major bug or an experienced developer who has dealt with complex production issues, your experience could help someone else facing a similar problem.

Share your story, solution, or lesson in the comments. Let’s make this a useful discussion for developers to learn from each other.

This is the kind of practical knowledge and developer conversation we love building around at Burj Code.]]>
            </summary>
                                    <updated>2026-09-07T21:28:58+00:00</updated>
        </entry>
            <entry>
            <title><![CDATA[I built an open-source native macOS app to manage Laravel de]]></title>
            <link rel="alternate" href="https://laravel.io/index.php/forum/i-built-an-open-source-native-macos-app-to-manage-laravel-de" />
            <id>https://laravel.io/index.php/30881</id>
            <author>
                <name><![CDATA[Luca Becchetti]]></name>
            </author>
            <summary type="html">
                <![CDATA[I work on multiple Laravel projects every day, and I got tired of keeping several terminal tabs open just to run artisbetan serve, queues, Horizon, Vite, Reverb, Sail, and everything else.

So I started building LaraDeck.

It automatically detects Laravel projects and lets you start, stop, and monitor their development services from a native macOS interface.

It’s still very early and completely open source.

I’m looking for Laravel developers on macOS who are willing to try it, break things, and tell me what sucks.

👉 https://laradeck.brokenice.it]]>
            </summary>
                                    <updated>2026-09-07T21:28:58+00:00</updated>
        </entry>
            <entry>
            <title><![CDATA[AI Agents as Teammates in Laravel Projects]]></title>
            <link rel="alternate" href="https://laravel.io/index.php/forum/ai-agents-as-teammates-in-laravel-projects" />
            <id>https://laravel.io/index.php/30880</id>
            <author>
                <name><![CDATA[luc]]></name>
            </author>
            <summary type="html">
                <![CDATA[AI agents are becoming part of Laravel development, but I’m curious how teams are managing them alongside human developers.

I’ve been exploring **Sharkly**, a project management platform where AI agents can be part of the same workflow as human teammates.

Instead of treating agents as separate tools, they can participate directly in tasks and projects.

Would you see value in having AI agents work alongside your Laravel team?]]>
            </summary>
                                    <updated>2026-09-07T21:28:58+00:00</updated>
        </entry>
            <entry>
            <title><![CDATA[How to Ensure Your Laravel APIs Follow OpenAPI Standards?]]></title>
            <link rel="alternate" href="https://laravel.io/index.php/forum/how-to-ensure-your-laravel-apis-follow-openapi-standards" />
            <id>https://laravel.io/index.php/30878</id>
            <author>
                <name><![CDATA[luc]]></name>
            </author>
            <summary type="html">
                <![CDATA[For Laravel APIs, it’s easy for the implementation and OpenAPI definition to drift apart as the project grows.

I’ve been looking at ways to catch this earlier instead of relying only on code reviews and manual testing.

One approach I found interesting is **Apidog’s Endpoint Compliance Check**, which can validate endpoints against defined API standards.

Combined with API testing and documentation checks, it gives teams a way to catch inconsistencies before they reach production.

For Laravel developers, how do you currently keep your API implementation and OpenAPI documentation in sync?]]>
            </summary>
                                    <updated>2026-09-07T21:28:58+00:00</updated>
        </entry>
            <entry>
            <title><![CDATA[API Governance Tool for Laravel: Keeping OpenAPI, Tests and]]></title>
            <link rel="alternate" href="https://laravel.io/index.php/forum/api-governance-tool-for-laravel-keeping-openapi-tests-and" />
            <id>https://laravel.io/index.php/30875</id>
            <author>
                <name><![CDATA[luc]]></name>
            </author>
            <summary type="html">
                <![CDATA[I've been working with Laravel APIs and one problem keeps coming up as projects get larger: keeping the API implementation, tests and documentation consistent.

Laravel makes it easy to build and test APIs, but there are still several things that can drift over time:

OpenAPI definitions becoming outdated
Missing endpoint documentation
Inconsistent response structures
Breaking changes going unnoticed
Authentication requirements changing
Exposed API secrets
Different teams following different API conventions

I've been testing Apidog as an API Governance Tool to see how much of this can be handled before an API reaches production.

What I found interesting is that it combines API design, testing and governance, with features such as:

Endpoint Compliance Check for enforcing API standards
API Documentation Completeness Check for finding incomplete documentation
Secret Scanner for detecting exposed credentials
RBAC for managing team access
Audit Logs for tracking changes

For a Laravel API, I'm thinking about a workflow like:

Laravel → OpenAPI → Apidog governance checks → API tests → CI/CD → production

This seems particularly useful when several developers are working on the same API and simply relying on code review isn't enough to keep everything consistent.

I'm curious how other Laravel developers handle this.

Do you rely on PHPUnit/Pest + OpenAPI tooling, custom CI rules, or a dedicated API governance tool?

And how do you currently detect when your Laravel implementation and OpenAPI documentation start drifting apart?]]>
            </summary>
                                    <updated>2026-09-07T21:28:58+00:00</updated>
        </entry>
            <entry>
            <title><![CDATA[Top 10 On-Premises API Testing Platforms Like Postman for La]]></title>
            <link rel="alternate" href="https://laravel.io/index.php/forum/top-10-on-premises-api-testing-platforms-like-postman-for-la" />
            <id>https://laravel.io/index.php/30877</id>
            <author>
                <name><![CDATA[luc]]></name>
            </author>
            <summary type="html">
                <![CDATA[Laravel makes API development and testing relatively straightforward. But when a Laravel application is used inside an enterprise environment, the question isn't only how to test an endpoint.

It's also about where API data, credentials, environments, and testing workflows are managed.

For teams working with private infrastructure, sensitive data, or strict security requirements, an on-premises API testing platform like Postman can be worth considering.

Here are 10 options and approaches I'd look at.

1. Apidog

Best overall for enterprise Laravel API development

Apidog would be my first option for teams looking for an on-premises API testing platform like Postman.

It goes beyond request testing by combining:

API design
API testing
Automated testing
Documentation
Mocking
Collaboration
Environment management
Enterprise access control

Apidog also provides on-premises and self-hosting options, which makes it interesting for Laravel applications that need to remain inside private infrastructure.

A possible Laravel workflow would be:

Laravel API → OpenAPI → Apidog → API testing → CI/CD → production

Best for: teams that want API testing and the broader API lifecycle in one platform.

2. Bruno

Best for Git-native Laravel teams

Bruno's local-first approach can work particularly well for Laravel developers who already keep API definitions and development workflows in Git.

Best for: teams that want API collections managed alongside their code.

3. Hoppscotch

Best open-source self-hosted option

Hoppscotch provides a browser-based API client with a self-hosting option.

Best for: teams looking for an open-source API testing environment.

4. Insomnia

Best for local desktop API development

Insomnia provides a desktop workflow for REST, GraphQL and other API development tasks.

Best for: developers who prefer a dedicated desktop API client.

5. Katalon

Best for broader QA automation

Katalon can be useful when API testing needs to be part of a larger web, mobile, and API automation strategy.

Best for: QA teams managing several testing types.

6. SoapUI

Best for REST and SOAP

SoapUI remains useful when a Laravel application needs to interact with legacy SOAP services as well as REST APIs.

Best for: mixed REST/SOAP environments.

7. SwaggerHub

Best for OpenAPI-focused teams

SwaggerHub can be useful when OpenAPI specifications are central to API design, documentation, and collaboration.

Laravel teams using OpenAPI as their API contract may find this workflow useful.

Best for: OpenAPI-centric teams.

8. Kong

Best for API gateway environments

Kong isn't a direct Postman replacement, but it becomes relevant when API testing is part of a larger API gateway architecture.

Best for: teams that need runtime API management alongside testing.

9. Laravel + PHPUnit/Pest + CI/CD

Best for teams that prefer native Laravel testing

Laravel already provides strong testing capabilities through PHPUnit and Pest.

A team can combine those tests with OpenAPI validation and CI/CD to build a completely internal API testing workflow.

Best for: Laravel teams that prefer code-first testing.

10. Custom Self-Hosted API Testing Stack

Best for specialized enterprise requirements

Some organizations combine OpenAPI, automated tests, CI/CD, security scanning, and custom tooling.

This provides maximum control but also means the team is responsible for maintaining the entire stack.

Best for: organizations with highly specialized infrastructure requirements.

Quick Comparison
Tool / approach	Self-hosted	API testing	OpenAPI	Automation	Best for
Apidog	Yes	Yes	Yes	Yes	Enterprise Laravel
Bruno	Local-first	Yes	Yes	Yes	Git workflows
Hoppscotch	Yes	Yes	Yes	Yes	Open-source
Insomnia	Local	Yes	Yes	Yes	Desktop testing
Katalon	Enterprise	Yes	Yes	Yes	QA automation
SoapUI	Yes	Yes	Yes	Yes	REST/SOAP
SwaggerHub	Enterprise	Yes	Yes	Yes	OpenAPI
Kong	Enterprise	Yes	Yes	Yes	API gateway
PHPUnit/Pest	Yes	Yes	Depends	Yes	Laravel-native testing
Custom stack	Yes	Yes	Depends	Yes	Specialized teams
What I'd Look At Before Choosing

For a Laravel API, I'd evaluate more than the request builder.

Infrastructure control: Where are API definitions, environments and test data stored?

Security: How are credentials and sensitive API information handled?

OpenAPI support: Can the API contract be shared between development, documentation and testing?

Automation: Can tests run in CI/CD?

Collaboration: Can developers and QA engineers work on the same API projects?

Deployment: Can the platform run inside the organization's own infrastructure?

My Pick

If you're just testing a local Laravel endpoint, PHPUnit, Pest, curl, or a lightweight API client may be all you need.

But if you're looking for an on-premises API testing platform like Postman for an enterprise Laravel environment, I'd put Apidog at the top because it combines API testing with design, documentation, mocking, collaboration, and enterprise deployment options.

The interesting question isn't simply:

"What's the best Postman alternative?"

It's:

"How much control do we need over our API testing infrastructure?"

For some Laravel projects, the answer will be a local test suite.

For others, a self-hosted API platform may make more sense.

What are you using today for Laravel API testing when cloud-based tooling isn't an option?]]>
            </summary>
                                    <updated>2026-09-07T21:28:58+00:00</updated>
        </entry>
            <entry>
            <title><![CDATA[Laravel After Deploy book is out]]></title>
            <link rel="alternate" href="https://laravel.io/index.php/forum/laravel-after-deploy-book-is-out" />
            <id>https://laravel.io/index.php/30876</id>
            <author>
                <name><![CDATA[milon]]></name>
            </author>
            <summary type="html">
                <![CDATA[Eleven years ago I wrote my first book, on Laravel. It did well: two editions, and the copies sold quickly. The years since have not been a straight line. I left Bangladesh, spent five years in Europe, and have now been in Canada for a little over three and a half years, working at companies of every size.

Whenever a colleague found that first book on my LinkedIn profile, they asked if they could read it. They could not. It was written in Bengali, against Laravel 5, for beginners, and it has been out of date for a long time.

The first book was for people just starting. This one is for mid-to-senior engineers. Building a Laravel application is the easy part. The hard part starts after deploy, which is also where most books and tutorials stop. This book starts there.

There are 46 chapters. Almost every one opens with a real production incident, then explains why it happened and how you recover from it. I was there for each of them, on my own team or a sister team, and I worked on the recovery. Company names are changed. I folded the incidents into a handful of fictional companies and kept those names consistent, so a system you meet in one chapter is still that system later in the book. Not every incident happened on a Laravel app. The examples are Laravel. The problems are not. If you can read PHP, you can take the patterns home.

The book is **Laravel After Deploy: Architecture, Performance, and Operations at Scale**. 46 chapters, 736 pages, eight parts. The first two parts are the foundation the rest of the book assumes. After that, most parts stand on their own.

The free sample has the front matter and three full chapters: Chapter 9 on schema evolution, Chapter 16 on rate limiting, and Chapter 25 on datetime and timezones.

I learned from the first book that this is not how you make money. The time that went into this one would have paid better as consulting. I took a lot from this community, and this is what I can put back. Kindle, PDF, and EPUB are $12.99. The paperback is $44.99, because printing 736 pages is expensive. I thought about giving it away. In my experience, a free book does not get read. So the digital price is a floor, not a target. The first 100 PDF or EPUB purchases get 15% off with the code `LAUNCH15` at checkout.

Site (sample is on the page): [https://laravel-after-deploy.milon.im](https://laravel-after-deploy.milon.im) 

Amazon: [https://mybook.to/laravel-after-deploy](https://mybook.to/laravel-after-deploy) 

PDF and EPUB: [https://store.milon.im/laravel-after-deploy](https://store.milon.im/laravel-after-deploy)]]>
            </summary>
                                    <updated>2026-09-07T21:28:58+00:00</updated>
        </entry>
            <entry>
            <title><![CDATA[How do you structure safe multi-step forms in Livewire?]]></title>
            <link rel="alternate" href="https://laravel.io/index.php/forum/how-do-you-structure-safe-multi-step-forms-in-livewire" />
            <id>https://laravel.io/index.php/30873</id>
            <author>
                <name><![CDATA[codegenie-be]]></name>
            </author>
            <summary type="html">
                <![CDATA[When a Livewire form spans several steps, the UI is the easy part. The harder questions are usually server-side:

- Do you validate only the current step or the whole form?
- How do you prevent direct final submission before the review step?
- How do you keep select values constrained to configured options?
- Where do Laravel rule objects or closures live without exposing them as public Livewire state?
- Who owns persistence and authorization?

The pattern I settled on is:

1. Validate the current step before advancing.
2. Generate a review step dynamically.
3. Accept final submission only from that review step.
4. Revalidate the complete form on submission.
5. Pass only configured, validated fields to an application-owned hook.
6. Keep persistence, authorization, mail, redirects, rate limiting, and retention in the application.

I extracted this into an MIT-licensed package and published v1.0.0 today:

`composer require codegenie-be/laravel-livewire-multistep-form`

It supports Laravel 12–13 and Livewire 3.6+/4.x, includes accessible markup and EN/NL/FR interface copy, and does not store data or call external services.

Repository: https://github.com/Codegenie-BE/laravel-livewire-multistep-form
Demo: https://laravel-livewire.codegenie.be
Packagist: https://packagist.org/packages/codegenie-be/laravel-livewire-multistep-form

Disclosure: I maintain the package through Codegenie. I am mainly looking for technical feedback: what validation, accessibility, or customization edge cases do you encounter in production multi-step forms?]]>
            </summary>
                                    <updated>2026-09-07T21:28:58+00:00</updated>
        </entry>
            <entry>
            <title><![CDATA[How do you catch Laravel environment drift before deploy?]]></title>
            <link rel="alternate" href="https://laravel.io/index.php/forum/how-do-you-catch-laravel-environment-drift-before-deploy" />
            <id>https://laravel.io/index.php/30872</id>
            <author>
                <name><![CDATA[codegenie-be]]></name>
            </author>
            <summary type="html">
                <![CDATA[One failure mode I keep seeing is application code that works locally but behaves differently after `php artisan config:cache` because it reads an environment variable directly:

```php
$token = env('ACME_TOKEN');
```

## The normal Laravel fix

The primary solution is to move the environment lookup into a configuration file:

```php
// config/services.php
return [
    'acme' => [
        'token' => env('ACME_TOKEN'),
    ],
];
```

Application code should then read it through Laravel's configuration repository:

```php
$token = config('services.acme.token');
```

I also test deployment builds with configuration cached. That catches the direct-access problem before production.

## Environment-file drift remains

A related issue is keeping the key inventories of `.env`, `.env.testing`, `.env.production`, `.env.sample`, or renamed templates aligned without comparing or exposing their values.

Some practical questions for teams maintaining several environments:

- Do you treat every `.env.*` file as a complete contract, or are some of them partial Vite-style layers?
- How do you detect a key used by application code but declared nowhere?
- How do you handle keys consumed only by Docker, CI, a process manager, or hosting infrastructure without producing false positives?
- Do commented assignments in non-active templates count as documented optional keys in your workflow?
- Do you audit raw `getenv()`, `$_ENV`, `$_SERVER`, Vite, Blade, and PHPUnit usage as part of the same review?

## An optional development guard

While working through these cases, I built the open-source [Laravel Env Guard](https://github.com/Codegenie-BE/laravel-env-guard):

```bash
composer require --dev codegenie-be/laravel-env-guard
```

It runs during guarded Artisan boots in the local environment by default. It checks unsafe `env()` usage and environment-key drift, but reports keys only: no values, telemetry, network calls, automatic `.env` changes, or production scanning by default. The current release supports Laravel 12 and 13 across their valid PHP 8.2–8.5 combinations.

Disclosure: I maintain this package through Codegenie. I am looking for technical feedback about real-world environment-file conventions and false-positive or false-negative cases, not stars. Please do not share real environment values or secrets.]]>
            </summary>
                                    <updated>2026-09-07T21:28:58+00:00</updated>
        </entry>
            <entry>
            <title><![CDATA[Best Practices for Building Secure Payment APIs in Laravel]]></title>
            <link rel="alternate" href="https://laravel.io/index.php/forum/best-practices-for-building-secure-payment-apis-in-laravel" />
            <id>https://laravel.io/index.php/30871</id>
            <author>
                <name><![CDATA[Niketan Sharma]]></name>
            </author>
            <summary type="html">
                <![CDATA[Been building out a payment API in Laravel recently and figured I'd share some of the practices that have made the biggest difference for us. Payment endpoints are a different beast compared to a typical CRUD API — the cost of a mistake is real money, not just a bad UX. Curious to hear what others are doing too.

**1. Never Store Raw Card Data**

This is the first rule and it's non-negotiable. Use a tokenized payment processor (Stripe, Braintree, etc.) and store only the token/reference ID in your database. Storing raw PANs or CVVs yourself pulls your entire app into PCI-DSS scope, which is a massive compliance burden most teams don't need to take on.

```
php
// Good — store only the processor's token
$payment = Payment::create([
    'user_id' => $user->id,
    'processor_token' => $charge->id, // e.g. Stripe charge/payment intent ID
    'amount' => $amount,
    'status' => 'pending',
]);
```
**2. Enforce Idempotency on Every Write Endpoint**

Network retries, double-taps on the frontend, and queue redelivery can all cause the same charge or transfer request to hit your API twice. Require an Idempotency-Key header and store a hash of processed keys so a repeated request returns the original result instead of creating a duplicate transaction.

```
php
if (Cache::has("idempotency:{$key}")) {
    return Cache::get("idempotency:{$key}");
}
```

Laravel doesn't do this for you out of the box, so it's worth building as reusable middleware if you're handling any kind of money movement.

**3. Use Database Transactions + Locking for Balance Updates**

Never do a read-then-write balance update without locking the row. Race conditions here are exactly how double-spends happen.

```
php
DB::transaction(function () use ($walletId, $amount) {
    $wallet = Wallet::where('id', $walletId)->lockForUpdate()->first();

    if ($wallet->balance < $amount) {
        throw new InsufficientFundsException();
    }

    $wallet->decrement('balance', $amount);
});
```

**4. Rate Limit Aggressively on Financial Endpoints**

Laravel's built-in throttle middleware is a good start, but for payment endpoints specifically, consider tighter limits and per-user (not just per-IP) throttling to blunt card-testing and enumeration attacks.

```
php
Route::middleware('throttle:10,1')->group(function () {
    Route::post('/payments/charge', [PaymentController::class, 'charge']);
});
```

**5. Verify Webhooks Cryptographically**

If you're consuming webhooks from a payment processor, always verify the signature before trusting the payload. Don't just check that the request "looks right."

```
php
$sig = $request->header('Stripe-Signature');
$event = \Stripe\Webhook::constructEvent($payload, $sig, config('services.stripe.webhook_secret'));
```

**6. Log Everything, But Never Log Sensitive Data**

Full audit trails matter a lot for financial systems — who initiated a transaction, when, from where. Just make sure your logging channel scrubs card numbers, tokens, and auth headers before anything hits disk.

**7. Use Policies/Gates for Every Financial Action**

Don't rely on route middleware alone. Wrap every transfer, withdrawal, or balance-changing action in an explicit authorization check via Laravel's Policy classes, so it's obvious and testable that a user can only act on their own wallet/account.

None of this is Laravel-specific in principle — it's standard fintech engineering discipline — but Laravel gives you solid primitives (transactions, middleware, policies, queues) to implement it cleanly if you use them deliberately rather than bolting security on after the fact. At Nimble AppGenie we've run into a lot of these issues while working on [fintech APIs](https://www.nimbleappgenie.com/blogs/top-fintech-apis-for-every-startup/) for wallet and payment products, and idempotency + row locking are consistently where teams get bitten first.

What are others doing for fraud detection or velocity checks at the API layer? That's the piece I'm still refining.]]>
            </summary>
                                    <updated>2026-09-07T21:28:58+00:00</updated>
        </entry>
            <entry>
            <title><![CDATA[Laravel Route / Controller Bypass Issue with Apache]]></title>
            <link rel="alternate" href="https://laravel.io/index.php/forum/laravel-route-controller-bypass-issue-with-apache" />
            <id>https://laravel.io/index.php/30869</id>
            <author>
                <name><![CDATA[Md.Manirul Islam]]></name>
            </author>
            <summary type="html">
                <![CDATA[Problem Description

Hello Laravel Community,

I am facing a strange issue with my Laravel application running on Apache + PHP 8.2-FPM.

Sometimes a specific route appears to return a response without reaching the expected Laravel controller. I am investigating whether Apache configuration, .htaccess, routing, middleware, caching, or another server-level rule could be bypassing Laravel's normal request flow.

Environment
Laravel application
Apache2
PHP 8.2-FPM
Ubuntu/Linux server
HTTPS enabled
Domain: xxxxxxxx
DocumentRoot: /var/results/public
Active Apache VirtualHost

According to:

sudo apachectl 
Laravel .htaccess

The public directory contains the standard Laravel rewrite rule:

RewriteEngine On

RewriteCond %{REQUEST_FILENAME} !-d
RewriteCond %{REQUEST_FILENAME} !-f
RewriteRule ^ index.php [L]

Therefore, if /master is not a physical file or directory, I expect the request flow to be:

Request: /master
        ↓
Apache
        ↓
public/.htaccess
        ↓
public/index.php
        ↓
Laravel Router
        ↓
Middleware
        ↓
Controller

However, I want to confirm whether there could be any other Apache-level configuration or caching mechanism causing the route to bypass Laravel.
Questions
Can Apache serve a response for /master without Laravel receiving the request, even when the Laravel .htaccess rule sends non-existing files/directories to index.php?
What is the best way to trace the complete request flow from:
Apache → .htaccess → index.php → Laravel middleware → controller
Are there any Apache modules, caching mechanisms, VirtualHost directives, or PHP-FPM configurations that could cause a Laravel route to behave unexpectedly?
What debugging method would you recommend to confirm whether a request actually reaches Laravel's public/index.php?

Any guidance would be appreciated. Thank you!]]>
            </summary>
                                    <updated>2026-09-07T21:28:58+00:00</updated>
        </entry>
            <entry>
            <title><![CDATA[Where Should Stablecoin Logic Actually Live?]]></title>
            <link rel="alternate" href="https://laravel.io/index.php/forum/where-should-stablecoin-logic-actually-live" />
            <id>https://laravel.io/index.php/30868</id>
            <author>
                <name><![CDATA[Ishan Maity]]></name>
            </author>
            <summary type="html">
                <![CDATA[Building a stablecoin is not simply a matter of writing a token contract and deploying it. The interesting engineering problem starts when on-chain logic has to communicate with everything happening outside the blockchain.

The smart contract can handle token balances, transfers, permissions, and other predefined rules. But what happens when the system needs pricing data, user management, transaction monitoring, analytics, compliance workflows, or administrative controls?

That is where the backend becomes important.

**What Should Stay On-Chain?**

The blockchain is useful when something needs transparent, deterministic execution. Token transfers, balances, minting rules, burning mechanisms, and critical ownership logic are obvious candidates.

But putting all application logic on-chain can create unnecessary cost and complexity.

A backend can handle operations that don't require decentralized execution, such as indexing blockchain events, serving APIs, managing application data, processing notifications, and coordinating user-facing workflows.

The challenge is deciding where that boundary should exist.

**So Where Should the Boundary Be?**

There probably isn't one universal answer.

Critical asset logic generally benefits from deterministic on-chain execution, while application-heavy operations can often remain off-chain.

The right architecture depends on the stablecoin model, blockchain network, security requirements, transaction volume, compliance needs, and expected user experience.

An end-to-end [stablecoin development](https://devtechnosys.com/stablecoin-development-services.php) approach therefore isn't about putting everything on-chain. It is about designing the right relationship between smart contracts, backend services, databases, wallets, APIs, and blockchain infrastructure.

The interesting question for developers is this:

**If you were designing a production stablecoin today, which responsibilities would you keep on-chain, and which would you deliberately move to the backend?**]]>
            </summary>
                                    <updated>2026-09-07T21:28:58+00:00</updated>
        </entry>
            <entry>
            <title><![CDATA[Could a Git-Native API Workspace Work Well With Laravel?]]></title>
            <link rel="alternate" href="https://laravel.io/index.php/forum/could-a-git-native-api-workspace-work-well-with-laravel-1" />
            <id>https://laravel.io/index.php/30867</id>
            <author>
                <name><![CDATA[luc]]></name>
            </author>
            <summary type="html">
                <![CDATA[I've been thinking about how Laravel teams manage their API contracts as applications grow.

For a small API, keeping an OpenAPI file up to date isn't too difficult. But once several developers are changing routes, request validation, resources, and response structures, keeping the API contract synchronized can become challenging.

One workflow I'm interested in is a git-native API workspace, where the OpenAPI specification lives directly in the repository and follows the same workflow as the Laravel application.

Something like:

OpenAPI → Git branch → PR review → validation → API tests → deployment

This could make API changes more visible during code review.

For example, a PR that changes a Laravel API endpoint could also include the corresponding OpenAPI change. CI could then validate the specification and run tests against it before merging.

I've been experimenting with Apidog's Spec-first workflow for this approach. The interesting part for me is that the API specification remains connected to Git rather than becoming a separate artifact that developers have to remember to synchronize later.

I'm curious how other Laravel developers handle this today.

Do you keep your OpenAPI specification in Git?
Do you generate the schema from Laravel code or design it first?
Do you validate API responses against the OpenAPI definition?
Are API contract changes reviewed as part of normal pull requests?
Would a git-native API workspace make this workflow easier?

I'm particularly interested in teams using Laravel as an API backend where several developers are working on the API simultaneously.]]>
            </summary>
                                    <updated>2026-09-07T21:28:58+00:00</updated>
        </entry>
            <entry>
            <title><![CDATA[Could a Git-Native API Workspace Work Well With Laravel?]]></title>
            <link rel="alternate" href="https://laravel.io/index.php/forum/could-a-git-native-api-workspace-work-well-with-laravel" />
            <id>https://laravel.io/index.php/30866</id>
            <author>
                <name><![CDATA[luc]]></name>
            </author>
            <summary type="html">
                <![CDATA[I've been thinking about how Laravel teams manage their API contracts as applications grow.

For a small API, keeping an OpenAPI file up to date isn't too difficult. But once several developers are changing routes, request validation, resources, and response structures, keeping the API contract synchronized can become challenging.

One workflow I'm interested in is a git-native API workspace, where the OpenAPI specification lives directly in the repository and follows the same workflow as the Laravel application.

Something like:

OpenAPI → Git branch → PR review → validation → API tests → deployment

This could make API changes more visible during code review.

For example, a PR that changes a Laravel API endpoint could also include the corresponding OpenAPI change. CI could then validate the specification and run tests against it before merging.

I've been experimenting with Apidog's Spec-first workflow for this approach. The interesting part for me is that the API specification remains connected to Git rather than becoming a separate artifact that developers have to remember to synchronize later.

I'm curious how other Laravel developers handle this today.

Do you keep your OpenAPI specification in Git?
Do you generate the schema from Laravel code or design it first?
Do you validate API responses against the OpenAPI definition?
Are API contract changes reviewed as part of normal pull requests?
Would a git-native API workspace make this workflow easier?

I'm particularly interested in teams using Laravel as an API backend where several developers are working on the API simultaneously.]]>
            </summary>
                                    <updated>2026-09-07T21:28:58+00:00</updated>
        </entry>
            <entry>
            <title><![CDATA[Laravel Rick 0.1.0 - durable AI workflows for Laravel]]></title>
            <link rel="alternate" href="https://laravel.io/index.php/forum/laravel-rick-010-durable-ai-workflows-for-laravel" />
            <id>https://laravel.io/index.php/30863</id>
            <author>
                <name><![CDATA[parmuzin]]></name>
            </author>
            <summary type="html">
                <![CDATA[Laravel Rick 0.1.0 — durable AI workflows for Laravel  Making a single AI request from Laravel is straightforward. Keeping a multi-step AI workflow reliable after the HTTP request ends is a different problem.

  What happens when a queue job is delivered twice? When an application must pause for human review? When several model calls finish in a different order? When a paid request times out and it is unclear
  whether the provider accepted it?

  I built Laravel Rick to handle that workflow lifecycle inside Laravel.

  Laravel Rick turns typed workflow definitions into deterministic compiled plans and durable, tenant-aware runs. Workflows can execute synchronously or continue through Laravel queues without relying
  on PHP process memory.

  ## Quick example

  ```php
  use Rick\Laravel\Rick;

  $rick = app(Rick::class);

  $workflow = $rick->workflow('summary')
      ->rawPrompt('Summarize the latest customer feedback.')
      ->build();

  $run = $rick->run($workflow);

  echo $run->output();

  Installation:

  composer require rickphp/laravel-rick:^0.1
  php artisan migrate

  ## What it currently supports

  - synchronous and queued workflow execution;
  - Laravel AI provider calls;
  - parallel operations with deterministic result ordering;
  - manual review, candidate selection and external input;
  - encrypted, tenant-scoped persistence;
  - pricing and resource budgets;
  - run metrics, snapshots and timelines;
  - transactional outbox delivery;
  - recovery of interrupted runs;
  - protection against blindly repeating ambiguous paid requests.

  One of the included examples generates five independent implementation plans, persists all five candidates, pauses the workflow for human review and continues only after the application selects a
  candidate.

  Another example dispatches independent operations through Laravel queues. Results are reduced in declaration order even if workers complete them in a different order. Duplicate delivery of an already
  completed invocation does not trigger another provider call.

  Laravel Rick 0.1.0 supports PHP 8.3+ and Laravel 12–13. It is open source under the MIT license.

  This is the first public release, so the API may still evolve before 1.0.

  I would especially appreciate feedback on:

  1. Is the workflow-building API understandable?
  2. Which real Laravel AI workflow would you try to implement with it?
  3. What is missing from the installation or use-case documentation?

  GitHub:
  https://github.com/para1992/laravel-rick

  Packagist:
  https://packagist.org/packages/rickphp/laravel-rick

  Release:
  https://github.com/para1992/laravel-rick/releases/tag/v0.1.0

  Issues and feature requests:
  https://github.com/para1992/laravel-rick/issues/new/choose]]>
            </summary>
                                    <updated>2026-09-07T21:28:58+00:00</updated>
        </entry>
    </feed>
