DEV Community: Matteo Barbero

How to test Filament resources | Laravel Personal Finance Dashboard

Matteo Barbero — Thu, 19 Feb 2026 09:41:59 +0000

Now that we have our resources set up, it's time to ensure they work as expected—and stay that way. In this lesson, we're going to write feature tests for our BankAccount, Budget, and Category resources. We'll focus particularly on ensuring that users can only see their own data.

Setting up Pest

First, we need to add Pest to our project. Pest is a testing framework with a focus on simplicity and elegance.

composer require pestphp/pest --dev --with-all-dependencies
php artisan pest:install

We also need to make sure our User model is ready for Filament testing. To properly simulate a Filament user in our tests, our User model should implement the FilamentUser contract. This ensures that when we use actingAs, the user is correctly recognized as having access to the panel.

Update app/Models/User.php:

use Filament\Models\Contracts\FilamentUser;
// ...

class User extends Authenticatable implements FilamentUser
{
    // ...

    public function canAccessPanel(\Filament\Panel $panel): bool
    {
        return true;
    }
}

You can view the setup and model changes in this commit.

Testing the Bank Account Resource

Let's start with the BankAccountResource. We want to verify that we can:

Render the page.
List bank accounts belonging to the user.
NOT list bank accounts belonging to other users.
Create, edit, and delete accounts.

Create a new test file: tests/Feature/Filament/Resources/BankAccountResourceTest.php.

Rendering and Listing

We use actingAs($user) to sign in as a user, and then access the page URL.

use App\Filament\Resources\BankAccounts\Pages\ManageBankAccounts;
use App\Models\BankAccount;
use App\Models\User;
use Livewire\Livewire;
use function Pest\Laravel\actingAs;

it('can render page', function () {
    $user = User::factory()->create();

    actingAs($user)
        ->get(ManageBankAccounts::getUrl())
        ->assertSuccessful();
});

it('can list bank accounts', function () {
    $user = User::factory()->create();
    $bankAccount = BankAccount::factory()->for($user)->create();

    Livewire::actingAs($user)
        ->test(ManageBankAccounts::class)
        ->assertCanSeeTableRecords([$bankAccount]);
});

Testing Scope (The "Other User" Test)

This is a critical test. We create a user and another user. We expect the current user effectively not to see the other user's record.

it('cannot see other users bank accounts', function () {
    $user = User::factory()->create();
    $otherUser = User::factory()->create();
    $otherBankAccount = BankAccount::factory()->for($otherUser)->create();

    Livewire::actingAs($user)
        ->test(ManageBankAccounts::class)
        ->assertCanNotSeeTableRecords([$otherBankAccount]);
});

Actions: Create, Edit, Delete

Filament provides excellent helpers to test actions directly.

it('can create bank account', function () {
    $user = User::factory()->create();

    Livewire::actingAs($user)
        ->test(ManageBankAccounts::class)
        ->mountAction('create')
        ->setActionData([
            'name' => 'My Main Bank',
            'balance' => '1000.50',
        ])
        ->callMountedAction()
        ->assertHasNoActionErrors();

    assertDatabaseHas('bank_accounts', [
        'user_id' => $user->id,
        'name' => 'My Main Bank',
        'balance' => 100050, // Value as integer thanks to our Caster
    ]);
});

Notice how we assert the database has the value 100050 because of our logic handling money as integers!

You can see the full test suite for the Bank Account resource in this commit.

Budget and Category Resources

The tests for BudgetResource and CategoryResource follow the exact same pattern. We need to ensure that detailed actions like creating and editing work, but most importantly, we must verify the scoping rules.

For example, the Category tests ensure that a user can only edit their own categories.

You can check the implementation for the Budget resource tests here and the Category resource tests here.

Running the Tests

Finally, let's run our test suite to see everything green!

php artisan test

You should see an output confirming that all resource tests are passing:

PASS Tests\Feature\Filament\Resources\BankAccountResourceTest
✓ it can render page
✓ it can list bank accounts
✓ it cannot see other users bank accounts
...

🎓 Build this App & Get Certified (Free)

If you found this guide helpful, you can build the entire application from scratch with my free course.

What you'll learn:

🏗️ Advanced Laravel Architecture
📊 Building Dashboards with FilamentPHP
💰 Handling Money professionally in code

→ Join other students on maiobarbero.dev

Happy coding!

How to build a Voice-to-Text App with Laravel AI SDK

Matteo Barbero — Wed, 11 Feb 2026 08:39:27 +0000

Stop Writing Boilerplate: Build a Voice-to-Text App with Laravel AI SDK

If you are a PHP developer, you have likely looked at AI integration with a mix of excitement and fatigue. Excitement for the possibilities, but fatigue from WRITING THE SAME BOILERPLATE code to handle multipart requests, API keys, and error handling for OpenAI or Anthropic.

The new Laravel AI SDK changes this. It turns complex AI interactions into fluid, Laravel-style syntax.

In this guide, we won't just talk about it—we will build a functional Voice-to-Text application in under 10 minutes. I call mine "Dettami", but you can call yours whatever you want.

Let's write some code.

Prerequisites

Laravel 10+ (or the latest version)
PHP 8.2+
An OpenAI API Key

Step 1: Install the SDK

First, forget about guzzlehttp/guzzle manual calls. Pull in the first-party package.

composer require laravel/ai

Once installed, publish the configuration file. This is where you will define your "drivers" (OpenAI, Gemini, Mistral, etc.).

php artisan install:ai

Add your key to your .env file:

OPENAI_API_KEY=...

Step 2: Define the Route

We need a single endpoint to accept the audio file. In your routes/web.php or routes/api.php:

use App\Http\Controllers\TranscribeAudioController;

Route::post('/transcribe', TranscribeAudioController::class)->name('transcribe');

Step 3: The Logic (Where the Magic Happens)

This is the part that usually hurts. Handling file uploads + external API calls is often messy.

Create your controller:

php artisan make:controller TranscribeAudioController --invokable

Now, look at how clean this solution is using the Transcription facade. We don't need to manually construct a POST request to https://api.openai.com/v1/audio/transcriptions. The SDK does it for us.

<?php

namespace App\Http\Controllers;

use Illuminate\Http\Request;
use Illuminate\Support\Facades\Storage;
use Laravel\AI\Facades\Transcription;

class TranscribeAudioController extends Controller
{
    public function __invoke(Request $request)
    {
        $request->validate([
            'audio' => 'required|file|mimes:webm,mp3,wav'
        ]);

        $file = $request->file('audio');

        // 1. Save the file temporarily
        // We need a physical path to pass to the SDK
        $path = $file->store('temp_recordings');
        $fullPath = Storage::path($path);

        try {
            // 2. Transcribe with one fluent method chain
            // The SDK automatically uses your configured default driver
            $text = Transcription::fromPath($fullPath, $file->getMimeType())
                ->generate();

            // 3. Cleanup
            Storage::delete($path);

            return response()->json([
                'success' => true,
                'text' => (string) $text,
            ]);

        } catch (\Throwable $e) {
            // Log the error and return a user-friendly message
            return response()->json(['error' => 'Transcription failed'], 500);
        }
    }
}

Why this matters

Notice line 27: Transcription::fromPath(...).
That is the abstraction we have been waiting for. It removes the cognitive load of remembering specific API parameters for every different provider. Today you use OpenAI, tomorrow you switch to Gemini—the code stays strictly the same.

Step 4: The Frontend (The "Recorder")

For the frontend, you don't need a heavy React app. A simple Blade view with vanilla JS covers it perfectly.

The core requirement is the browser's MediaRecorder API. Here is the pseudo-code for what your JavaScript needs to do:

Request Microphone access (navigator.mediaDevices.getUserMedia).
Record chunks of audio into a Blob.
Send that Blob to our Laravel endpoint via FormData.

Here is a glimpse of the UI I built for this:

Summary

We just built a fully functional Voice-to-Text backend in about 20 lines of code.

The Laravel AI SDK respects your time. It handles the "plumbing" so you can focus on building the actual product.

If you want to inspect the full source code for the demo project "Dettami", check the repository here:
GitHub: maiobarbero/dettami

Keep moving forward.

How to create a resource in Filament v5 | Laravel Personal Finance Dashboard

Matteo Barbero — Tue, 10 Feb 2026 07:15:52 +0000

👋 Note: This article is an excerpt from my Free Laravel & Filament Finance Course.
The full course includes code-along lessons, quizzes, and a Completion Certificate.

👉 Start the Free Course & Get Certified

The First Filament Admin Panel

We have our database structure. It's solid, typed, and waiting for data. But a database without an interface is like a library without doors, secure, but useless.

Today, we build the doors.

We are going to create our first Filament Resources. In Filament, a "Resource" is the static representation of an entity in your admin panel. It describes how your model looks in a table, how it behaves in a form, and how it relates to the rest of your application.

We will start with something fundamental: Categories.

1. Creating the Category Resource

Filament provides a powerful artisan command to generate resources. We want our categories to be manageable quickly, without navigating away from the list. We want a "Simple Resource", one that handles Creating, Reading, Updating, and Deleting (CRUD) all on a single page using modals.

Run this command:

php artisan make:filament-resource Category --simple

This generates two key files:

app/Filament/Resources/CategoryResource.php: The definition of the table and form.
app/Filament/Resources/CategoryResource/Pages/ManageCategories.php: The page controller that handles the actions.

You can see the initial structure in this commit.

If you visit /admin/categories now, you might see a form with a User dropdown. This is technically correct, a category belongs to a user, but practically wrong. When I create a category, it should be mine. I shouldn't have to select myself from a list.

2. Scoping and Context

We have two problems to solve:

Visibility: I can see categories belonging to other users.
Creation: I have to manually select the user.

Fixing Visibility

To ensure I only see my records, we strictly scope the Eloquent query used by the resource. We override the getEloquentQuery method in CategoryResource.php.

public static function getEloquentQuery(): \Illuminate\Database\Eloquent\Builder
{
    return parent::getEloquentQuery()->where('user_id', auth()->id());
}

Now, the table will only ever load records where user_id matches the logged-in user.

Fixing Creation

Next, we clean up the form. In CategoryResource::form(), remove the user_id input completely. We don't want the user to worry about it.

But the database needs that ID. So, we inject it programmatically.

In app/Filament/Resources/CategoryResource/Pages/ManageCategories.php, we modify the CreateAction. We use mutateFormDataUsing to intercept the form submission and add the current user's ID before it hits the database.

protected function getHeaderActions(): array
{
    return [
        CreateAction::make()
            ->mutateDataUsing(function (array $data): array {
                $data['user_id'] = auth()->id(); // <--- This implies the user
                return $data;
            }),
    ];
}

We also remove the user column from the table to keep it clean.

You can view the specific changes to scope the data in this commit.

3. Bank Accounts

Money needs a home. Let's apply the exact same logic to Bank Accounts.

Generate the resource: php artisan make:filament-resource BankAccount --simple.
Scope the query in BankAccountResource.
Inject the user_id in ManageBankAccounts.

If you check your database or use artisan tinker, you'll notice our MoneyCast is working silently in the background. When you type "1000" in the balance field, it's stored as 100000 (cents) in the database, assuming you treated the input as a distinct number.

Wait, there's a nuance here. Our form is currently generic. Later, we'll want to ensure we are handling decimals correctly in the UI so the user types "10.00" and we store "1000". For now, we are trusting the raw input.

Check the implementation of the Bank Account resource here.

4. Budgets and Presentation

Finally, let's tackle Budgets. This is where Filament's UI components really shine.

Generate the resource:

php artisan make:filament-resource Budget --simple

Budgets have a type (Reset or Rollover). In our database, this is an Enum string. In Filament, we want to visualize this instantly using colors.

The Badge Column

In BudgetResource.php, we can use a TextColumn but format it as a badge.

TextColumn::make('type')
    ->badge()
    ->color(fn (BudgetType $state): string => match ($state) {
        BudgetType::Reset => 'success',
        BudgetType::Rollover => 'warning',
    })
    ->searchable(),

This simple chaining transforms a boring text string into a vibrant, communicative UI element.

Formatting Money

We also want to display the budget amount as actual currency, not just a raw number. Filament has a dedicated money formatter.

TextColumn::make('amount')
    ->money('EUR')
    ->sortable(),

This creates a polished, professional look immediately.

You can explore the Budget resource implementation in this commit, and see how we refined the badge colors here.

Conclusion

We now have three functional pillars of our personal finance application:

Categories to label our spending.
Bank Accounts to store our wealth.
Budgets to control our impulses.

And importantly, they are completely private to the logged-in user.

In the next lesson, we will test our first Resources. Keep building.

🎓 Build this App & Get Certified (Free)

If you found this guide helpful, you can build the entire application from scratch with my free course.

What you'll learn:

🏗️ Advanced Laravel Architecture
📊 Building Dashboards with FilamentPHP
💰 Handling Money professionally in code

→ Join other students on maiobarbero.dev

Testing the New Laravel AI SDK: Building 'Dettami' a voice-to-text app

Matteo Barbero — Sat, 07 Feb 2026 13:46:06 +0000

The landscape of AI integration in PHP has just shifted. With the release of the Laravel AI SDK, what used to require complex API wrangling or third-party packages is now a first-party citizen of the framework we love.

I couldn't resist. I had to take it for a spin.

The result is Dettami (Italian for "Dictate to me"), a simple web app that records your voice and transcribes it instantly. And when I say "simple," I mean it. The speed at which I went from laravel new to a working prototype was exhilarating.

The Goal: Frictionless Audio Transcription

I wanted to build something tangible. Not just a "Hello World" for AI, but a feature I would actually use: a quick way to record thoughts and get them as text.

Here is what the interface looks like. Clean, focused, and ready to listen.

The Implementation

Installing the SDK was the first step, and as you'd expect from the Laravel ecosystem, it was seamless.

composer require laravel/ai

But the real magic happened in the controller. In the past, handling audio uploads, converting formats, and sending them to an API like OpenAI's Whisper or Google's Speech-to-Text involved a fair bit of boilerplate. You had to manage the file, ensure the format was correct, build the multipart request, handle the response...

With the Laravel AI SDK, the complexity vanishes. It abstracts the "how" and lets you focus on the "what."

Here is the core logic from my Dettami controller. Look at how expressive it is:

public function __invoke(Request $request)
{
    if ($request->hasFile('audio')) {
        $file = $request->file('audio');

        // Store the file temporarily
        $path = $file->storeAs('dettami', 'recording.webm');
        $fullPath = Storage::path($path);

        try {
            // The magic happens here. One fluents line.
            $transcription = Transcription::fromPath($fullPath, 'audio/webm')
                ->generate();

            // Clean up
            Storage::delete($path);

            return response()->json([
                'success' => true,
                'transcription' => (string) $transcription,
            ]);
        } catch (\Throwable $e) {
            // ... error handling
        }
    }
}

That's it. Transcription::fromPath(...) -> generate().

The SDK handles the heavy lifting of communicating with the configured AI provider. It feels native. It feels right.

The Frontend Experience

For the frontend, I kept it simple using Blade and vanilla JavaScript with the MediaRecorder API. The goal was to provide immediate feedback. You click record, you speak, you get text.

Beyond Transcription: Translation

The power of this SDK doesn't stop at transcription. Once you have the text, the possibilities are endless. You can summarize it, rewrite it, or—as I experimented with—translate it.

Because the SDK provides a unified interface for these operations, adding a translation step is just as trivial as the transcription itself. Whether you are using OpenAI, Anthropic, or Gemini, the code remains consistent and clean.

Reflections

Building Dettami was a reminder of why I love this framework. It respects my time. The Laravel AI SDK isn't just a wrapper; it's an opinionated, elegant way to bring intelligence into your applications without the headache.

For architects and developers, this means we can stop worrying about connecting to AI and start worrying about what we can build with it. Ideally, the barrier to entry has been lowered to the floor.

If you haven't tried it yet, fire up a terminal.

composer require laravel/ai

And build something amazing. You can find the full source code for Dettami on GitHub. I recommend starting with this commit to see the transcription logic in isolation.

Keep moving forward.

Laravel Personal Finance Dashboard: creating the database

Matteo Barbero — Thu, 05 Feb 2026 07:59:55 +0000

👋 Note: This article is an excerpt from my Free Laravel & Filament Finance Course.
The full course includes code-along lessons, quizzes, and a Completion Certificate.

👉 Start the Free Course & Get Certified

Creating the Database

Every great application stands on the shoulders of a solid data model. If the database schema isn't right, everything else, from your eloquently written controllers to your beautiful Filament resources, will feel like fighting gravity.

In this lesson, we are going to define the core entities of our Personal Finance application. We aren't just creating tables; we are defining the vocabulary of our domain.

The Entities

Our application needs to track money moving in and out. To do that effectively, we need four primary concepts:

Bank Accounts: Where the money lives.
Categories: How we classify the money (e.g., "Utilities", "Dining Out").
Budgets: Our financial goals or limits.
Transactions: The heart of the system, the actual record of spending or earning.

Generating the Artifacts

Laravel makes scaffolding these incredible easy. We need a Model, a Migration, a Factory, and a Seeder for each of our entities. Instead of running four commands per entity, we can use the -mfs flags.

Run the following commands in your terminal:

php artisan make:model Category -mfs
php artisan make:model Budget -mfs
php artisan make:model BankAccount -mfs
php artisan make:model Transaction -mfs

You should see a flurry of green success messages. We now have our files ready to be sculpted.

A Note on "Down" Methods

Open up one of your new migration files. You'll see an up method and a down method.

I'm going to ask you to do something that might feel rebellious: delete the down method.

Why? In this project, we are adopting a Fix Forward strategy. In a production environment with real data, rolling back a migration (especially one that drops columns or tables) is destructive and risky. If we make a mistake in a migration that has already run, we don't roll it back, we create a new migration to fix the issue. This keeps our database history linear and truthful.

So, go ahead and remove public function down(): void from all your new migration files. It clarifies our intent: we only move forward.

Defining the Schema

Let's define the structure of our tables.

1. Enums

Before we get to the tables, we need a way to define the type of a Budget. Is it a fixed budget that we reset every month? Or is it a rolling budget that we keep track of over time? Let's use a PHP Enum for this to ensure type safety.

php artisan make:enum Enums/BudgetType

Edit app/Enums/BudgetType.php:

<?php

namespace App\Enums;

enum BudgetType: string
{
    case Reset = 'reset';
    case Rollover = 'rollover';

    public function getLabel(): string
    {
        return match ($this) {
            self::Reset => 'Reset',
            self::Rollover => 'Rollover',
        };
    }
}

2. Migrations

Now, let's fill in our up methods.

create_categories_table.php
Categories are simple. They have a name and belong to a user.

Schema::create('categories', function (Blueprint $table) {
    $table->id();
    $table->foreignId('user_id')->constrained()->cascadeOnDelete();
    $table->string('name');
    $table->timestamps();

    $table->unique(['user_id', 'name']);
});

create_budgets_table.php
A budget tracks a limit for a specific period.

Schema::create('budgets', function (Blueprint $table) {
    $table->id();
    $table->foreignId('user_id')->constrained()->cascadeOnDelete();
    $table->string('name');
    $table->integer('amount')->default(0);
    $table->string('type')->default('fixed');
    $table->timestamps();
    $table->unique(['user_id', 'name']);
});

create_bank_accounts_table.php
Represents a physical or digital account.

Schema::create('bank_accounts', function (Blueprint $table) {
    $table->id();
    $table->foreignId('user_id')->constrained()->cascadeOnDelete();
    $table->string('name');
    $table->unsignedBigInteger('balance')->default(0);
    $table->timestamps();

    $table->unique(['user_id', 'name']);
});

create_transactions_table.php
The center of our universe. Links everything together.

Schema::create('transactions', function (Blueprint $table) {
    $table->id();
    $table->foreignId('user_id')->constrained()->cascadeOnDelete();
    $table->foreignId('bank_account_id')->constrained()->cascadeOnDelete();
    $table->string('description');
    $table->foreignId('category_id')->constrained()->cascadeOnDelete();
    $table->foreignId('budget_id')->constrained()->cascadeOnDelete();
    $table->date('date');
    $table->text('note')->nullable();
    $table->unsignedInteger('amount');
    $table->timestamps();
});

[!TIP]
Notice we store money as integers (cents) rather than floats or decimals. Floating point math can be imprecise. storing $10.00 as 1000 is deeply robust.

3. The Money Cast

Since we are storing money as integers (cents) but want to work with it as standard units (dollars/euros) in our code, let's create a custom Cast. This encourages consistency across our application.

Run:

php artisan make:cast MoneyCast

Update app/Casts/MoneyCast.php:

<?php

namespace App\Casts;

use Illuminate\Contracts\Database\Eloquent\CastsAttributes;
use Illuminate\Database\Eloquent\Model;

class MoneyCast implements CastsAttributes
{
    /**
     * Cast the given value.
     *
     * @param  array<string, mixed>  $attributes
     */
    public function get(Model $model, string $key, mixed $value, array $attributes): mixed
    {
        return $value / 100;
    }

    /**
     * Prepare the given value for storage.
     *
     * @param  array<string, mixed>  $attributes
     */
    public function set(Model $model, string $key, mixed $value, array $attributes): mixed
    {
        return (int) round($value * 100);
    }
}

4. The Models

Now we breathe life into our schemas by defining relationships and behaviors in our Models.

User.php
The user owns everything.

// ... imports
use Illuminate\Database\Eloquent\Relations\HasMany;

class User extends Authenticatable
{
    // ... traits

    // ... fillable & hidden

    public function bankAccounts(): HasMany
    {
        return $this->hasMany(BankAccount::class);
    }

    public function categories(): HasMany
    {
        return $this->hasMany(Category::class);
    }

    public function budgets(): HasMany
    {
        return $this->hasMany(Budget::class);
    }

    public function transactions(): HasMany
    {
        return $this->hasMany(Transaction::class);
    }
}

Category.php

class Category extends Model
{
    /** @use HasFactory<\Database\Factories\CategoryFactory> */
    use HasFactory;

    protected $fillable = [
        'user_id',
        'name',
    ];

    public function user(): \Illuminate\Database\Eloquent\Relations\BelongsTo
    {
        return $this->belongsTo(User::class);
    }

    public function transactions(): \Illuminate\Database\Eloquent\Relations\HasMany
    {
        return $this->hasMany(Transaction::class);
    }
}

Budget.php
Here we treat our type as an Enum and amount with our new MoneyCast.

class Budget extends Model
{
    /** @use HasFactory<\Database\Factories\BudgetFactory> */
    use HasFactory;

    protected $fillable = [
        'user_id',
        'name',
        'amount',
        'type',
    ];

    protected function casts(): array
    {
        return [
            'type' => \App\Enums\BudgetType::class,
            'amount' => \App\Casts\MoneyCast::class,
        ];
    }

    public function user(): \Illuminate\Database\Eloquent\Relations\BelongsTo
    {
        return $this->belongsTo(User::class);
    }

    public function transactions(): \Illuminate\Database\Eloquent\Relations\HasMany
    {
        return $this->hasMany(Transaction::class);
    }
}

BankAccount.php

class BankAccount extends Model
{
    /** @use HasFactory<\Database\Factories\BankAccountFactory> */
    use HasFactory;

    protected $fillable = [
        'user_id',
        'name',
        'balance',
    ];

    protected function casts(): array
    {
        return [
            'balance' => \App\Casts\MoneyCast::class,
        ];
    }

    public function user(): \Illuminate\Database\Eloquent\Relations\BelongsTo
    {
        return $this->belongsTo(User::class);
    }

    public function transactions(): \Illuminate\Database\Eloquent\Relations\HasMany
    {
        return $this->hasMany(Transaction::class);
    }
}

Transaction.php
The nexus. Note the mass assignment protection and casting.

class Transaction extends Model
{
    /** @use HasFactory<\Database\Factories\TransactionFactory> */
    use HasFactory;

    protected $fillable = [
        'user_id',
        'bank_account_id',
        'category_id',
        'budget_id',
        'description',
        'amount',
        'note',
        'date',
    ];

    protected function casts(): array
    {
        return [
            'amount' => \App\Casts\MoneyCast::class,
        ];
    }

    public function user(): \Illuminate\Database\Eloquent\Relations\BelongsTo
    {
        return $this->belongsTo(User::class);
    }

    public function bankAccount(): \Illuminate\Database\Eloquent\Relations\BelongsTo
    {
        return $this->belongsTo(BankAccount::class);
    }

    public function category(): \Illuminate\Database\Eloquent\Relations\BelongsTo
    {
        return $this->belongsTo(Category::class);
    }

    public function budget(): \Illuminate\Database\Eloquent\Relations\BelongsTo
    {
        return $this->belongsTo(Budget::class);
    }
}

Seeding and Verification

With our structure defined, let's spin up the database.

First, update your DatabaseSeeder.php to call the new seeders:

class DatabaseSeeder extends Seeder
{
    use WithoutModelEvents;

    /**
     * Seed the application's database.
     */
    public function run(): void
    {
        $this->call(UserSeeder::class);
        $this->call(CategorySeeder::class);
        $this->call(BudgetSeeder::class);
        $this->call(BankAccountSeeder::class);
        $this->call(TransactionSeeder::class);
    }
}

(We'll cover Factories in depth in a future lesson, but for now, ensure your factories create dummy data).

Then, run:

php artisan migrate:fresh --seeder

Now, let's verify our work using Tinker, the best tool for checking your data reality.

php artisan tinker

Try fetching a user and their transactions:

$user = \App\Models\User::first();
$user->transactions()->get();

If you see a Collection of Transaction models, congratulations. You have successfully mapped the physical world of finance into your digital domain.

Finally, before we commit, let's make sure our code style is impeccable.

./vendor/bin/pint

Keep moving forward.

🎓 Build this App & Get Certified (Free)

If you found this guide helpful, you can build the entire application from scratch with my free course.

What you'll learn:

🏗️ Advanced Laravel Architecture
📊 Building Dashboards with FilamentPHP
💰 Handling Money professionally in code

→ Join other students on maiobarbero.dev

Laravel Personal Finance Dashboard: setting up the project with Filament v5

Matteo Barbero — Tue, 03 Feb 2026 08:33:26 +0000

👋 Note: This article is an excerpt from my Free Laravel & Filament Finance Course.
The full course includes code-along lessons, quizzes, and a Completion Certificate.

👉 Start the Free Course & Get Certified

Starting a new project is always a mix of excitement and anxiety. The blank slate. Infinite possibilities. But today, we're not just writing code; we're building a tool for financial freedom. A system that serves us, tailored to our specific needs, without the bloat of generic SaaS products.

In this first lesson, we will lay the foundation. We are going to build a robust, modern application using strictly typed Laravel 12 and the elegant Filament admin panel.

Let's get our hands dirty.

1. The Foundation

First, let's create our canvas. Open your terminal and breathe in that new project smell.

laravel new laravel_filament_personal_finance

We want a clean slate, so when promoted, select:

No starter kit: We are building this artisan-style.
Pest: For testing. It’s elegant and expressive.
SQLite: Simplify the infrastructure. For a personal tool, it's fast, zero-conf, and easy to backup.
Init Git repo: Yes. Version control is non-negotiable.

Once the command finishes, navigate into your new fortress:

cd laravel_filament_personal_finance
composer install

Verify that the heart is beating:

php artisan serve

Visit http://localhost:8000. You should see the default Laravel splash screen. We are live.

View the initial setup commit

2. Supercharging with AI

I believe in leveraging every tool available to maintain flow. We'll add Laravel Boost, an MCP server that acts as a bridge between our app and AI agents. Think of it as giving your AI pair programmer direct sensory access to your codebase.

composer require laravel/boost --dev

Initialize it:

php artisan boost:install

When prompted, select your IDE or specific configuration. This will generate a configuration block like this (the below one is the Google Antigravity configuration):

{
    "mcpServers": {
        "laravel-boost": {
            "command": "/usr/bin/php",
            "args": [
                "/home/<your-username>/<path-to-project>/artisan",
                "boost:mcp"
            ]
        }
    }
}

Now, your AI assistant can understand your project structure, run artisan commands, and debugging becomes a conversation rather than a struggle.

View the Boost configuration commit

3. The Admin Panel

We don't want to spend weeks building authentication views and CRUD tables from scratch. We want to focus on the logic of our finances. Enter Filament v5. It’s the gold standard for TALL stack admin panels.

Install it via composer:

composer require filament/filament:"^5.0"

Now, install the panel. We'll call ours admin.

php artisan filament:install --panels

Enter admin when asked for the ID.

This scaffolds the entire admin infrastructure. It's almost magical how much time this saves us.

View the Filament setup commit

4. First Access

Reference without access is useless. Let's create an admin user to unlock the gates.

php artisan make:filament-user

Follow the prompts to set your name, email, and password. Then, restart your server if it's not running:

php artisan serve

Navigate to /admin. Login with your new credentials.

You are now looking at the control center of your future financial system. It's empty now, but soon it will be the source of truth for your wealth.

We have a running application, a powerful admin interface, and the AI tooling to help us build faster. The structure is set. In the next lesson, we will start modeling the domain.

Happy coding!

🎓 Build this App & Get Certified (Free)

If you found this guide helpful, you can build the entire application from scratch with my free course.

What you'll learn:

🏗️ Advanced Laravel Architecture
📊 Building Dashboards with FilamentPHP
💰 Handling Money professionally in code

→ Join other students on maiobarbero.dev

How to set up a global .gitignore

Matteo Barbero — Wed, 07 May 2025 06:33:13 +0000

If you work with multiple Git repositories, you’ve likely run into the frustration of ignoring the same files (like .DS_Store, Thumbs.db, or your IDE settings) over and over again. Fortunately, Git allows you to define a global .gitignore file that applies to all repositories on your system. This is done through the core.excludesfile configuration option.

In this article, I'll walk you through how to set up a global .gitignore file using git config.

🎯 Why Use a Global .gitignore?

Some files are specific to your system or development environment and should never be committed to any project. Examples include:

macOS system files (.DS_Store)
Windows thumbnails (Thumbs.db)
IDE configs (.idea/, .vscode/)
Log files (*.log)
Local environment files (.env)

Instead of duplicating the same ignore rules in every repo, a global .gitignore keeps things DRY (Don't Repeat Yourself).

🛠 Step-by-Step Setup

1. Create the Global .gitignore File

Start by creating a .gitignore_global file in your home directory (or anywhere you prefer):

touch ~/.gitignore_global

Then, edit it and add the rules you want:

# macOS
.DS_Store

# Windows
Thumbs.db

# IDEs
.vscode/
.idea/

# Logs
*.log

# Env files
.env

2. Configure Git to Use the Global File

Tell Git to use this file globally:

git config --global core.excludesfile ~/.gitignore_global

You can verify it worked with:

git config --global core.excludesfile

This should output the path you just set.

Introducing Astro Academia

Matteo Barbero — Mon, 03 Mar 2025 10:49:38 +0000

A Free Website Template for Academics

Astro Academia is a website template built using Astro, a modern static site generator. The template is designed to be easy to use and customize, even for those who may not have extensive web development experience. It includes several features that are particularly useful for academics, such as:

Publication List: Easily showcase your research papers and publications.
CV Page: Display your curriculum vitae in a clean and organized manner.
Blog: Share your thoughts and updates with a built-in blog.
Responsive Design: Ensure your website looks great on all devices.

Key Features

Easy to Customize

The template is built with simplicity in mind. You can easily customize the content and appearance of your website by editing a few configuration files and markdown files. The use of Tailwind CSS allows for easy styling adjustments.

Built with Astro

Astro is a modern static site generator that offers excellent performance and flexibility. It allows you to use your favorite front-end frameworks like React, Vue, or Svelte, while still generating static HTML for fast load times.

Free and Open Source

Astro Academia is completely free to use and open source. You can find the source code on GitHub. Contributions and feedback are welcome!

Getting Started

Following the official documentation you will be able to edit the layout and to add data like your cv and your pubblications. Astro Academia also support blog.

Conclusion

I created Astro Academia to help academics easily create and maintain their personal websites. It is a free and open-source template that is easy to use and customize. I hope this project can help many academics showcase their work and achievements without the hassle of building a website from scratch.

Feel free to check out the project on GitHub, or the official preview, and contribute if you have any improvements or suggestions!

Github repository
Preview
Astro Theme Page

Deploy a WordPress Theme with GitHub Actions

Matteo Barbero — Tue, 11 Jun 2024 08:56:07 +0000

Is it possible to deploy a WordPress theme directly from GitHub?

Minified code, “bundler” of various types, package manager for JavaScript and PHP and so forth… These are just some of the reasons for choosing to automate the deployment of a WordPress Theme.

Sure it’s always possible to upload files with ftp every time, but why do it manually when GitHub can take care of everything?

Welcome to the guide to automate the deployment

First, the theme code must be in a GitHub repository.

Create a .github folder inside the repo. Inside this folder create another folder called workflows and inside it a main.yml file. You can give this file any name you like, the important thing is to keep the .yml extension.

The folder structure will look like this: .github / workflows / main.yml

The .yml file

Let’s start creating our workflow to automate the deployment

name: Deploy via FTP
on:
  push:
    branches: [ main ]

name will simply be the name that we will display in the Actions tab of the repository

on: things get interesting here. We define our trigger here. In this case we want to deploy to the push, but we have added a filter: we are only interested in the push done to the main branch. In this way we can have a development branch, perhaps automating the deployment of this on a staging site as well.

jobs:
  build:
    runs-on: ubuntu-latest
    defaults:
      run:
        shell: bash

Now we come to the actions, jobs, which will follow, by default in parallel, our workflow. build will be the name of our only job

runs-on: where do we want to run our workflow? GitHub gives us several possibilities listed here.

The last three lines are used to set a default shell for all runs

 steps:
    - uses: actions/checkout@v2
      with:
        fetch-depth: 2
    - name: FTP Deploy WP Theme
      uses: SamKirkland/FTP-Deploy-Action@4.3.2
      with:
        server: FTP SERVER
        username: FTP USERNAME
        password: ${{ secrets.FTP_PASSWORD }}
        server-dir: FTP DIR
        exclude: |
          **/.git*
          **/.git*/**
          **/node_modules/**

We are at the final steps of our workflow. We just have to worry about writing our ftp server address and username, as well as the destination folder (our theme folder).

Since this file will be accessible from the repository, we can keep some settings like our password secret. To do this we can set a new secret key from the Setting / Secrets / Actions tab

Secret key GitHub repository
Are you tired of reading and just want to make a nice copy and paste? Find the .yml file and ready-made folder structure here

Deploy a Grafana dashboard with Docker on AWS EC2

Matteo Barbero — Tue, 07 May 2024 11:23:28 +0000

Monitoring system performance and logs with Grafana is indeed straightforward, especially when working with Docker environments. Grafana seamlessly integrates with Docker, providing prebuilt dashboards that instantly visualize key metrics and logs from your containers and hosts.

Launch EC2 instance

To embark on your AWS journey, you'll need a server instance, and AWS offers the perfect playground with its free tier. Launch a Linux instance effortlessly, and let the experimentation begin!

Click on launch EC2 instance and select t2.micro to use the free tier.

Here we need some more configurations:

Create a key pair (for the login) and download it in a safe place;
Add a security group or create a new one; -Allow traffic from both ssh and internet.

Now you can launch your EC2 instance

Open ports

For these project we need to open these ports:

3000 for Grafana
9090 for Prometheus
3100 for Loki
9100 for node-exporter

To do this:

navigate to the EC2 Dashboard and select your EC2 instance
click on the security group associated and the click edit
configure the inbound rule selecting Custom TCP Rule as the type. Enter the port number and select Anywhere as the source.
Repeat the last step for all the four ports

Install Docker

With your Linux instance up and running, it's time to unlock the power of containerization by installing Docker. This game-changing platform will enable you to effortlessly deploy and manage your applications, including the highly coveted Grafana dashboard.

Connect via ssh

In your terminal run

ssh -i "<path_to_your_key.pem>" ec2-user@<Public IPv4 DNS>

Type yes and you are inside your instance!

Install Docker and Docker Compose

To install Docker run:

sudo yum update
sudo yum install -y docker

Then we can install Docker Compose. Run:

sudo curl -L https://github.com/docker/compose/releases/latest/download/docker-compose-$(uname -s)-$(uname -m) -o /usr/local/bin/docker-compose

sudo chmod +x /usr/local/bin/docker-compose

Run Docker service

If everything since here went fine you only need to start the Docker daemon. To do this run:

sudo systemctl start docker
sudo systemctl enable docker

Copy the project

You can download the source code from the repo and copy it into the EC2 with scp, or clone directly into the EC2 instance, and check if git is installed.

To clone the repo run:

git clone https://github.com/maiobarbero/grafana-prometheus-loki.git

Edit the configuration's files

Now with vim edit the configuration file, in particular if you are using this repository edit config/prometheus/prometheus-config.yml and replace localhost with your private IP4.

Run the application

Here we are, the last step. Inside your project folder run

docker-compose up -d

And that's it.

Go to your-public-ip:3000 and you have your Grafana instance!!!

Cover image by Chris Liverani on Unsplash

Docker-compose cheat sheet

Matteo Barbero — Tue, 16 Jan 2024 15:19:09 +0000

A cheat sheet to create you docker-compose.yml version: '3.8'

Build the image

web:
  # build from Dockerfile
  build: .
  # alternative to use a folder with more than one Dockerfile:
  build:
    context: ./dir # path to Dockerfile
    dockerfile: Dockerfile.dev #name of the file
    target: dev # specify the target in a multi-stage build
  # build from image
  image: ubuntu
  image: ubuntu:14.04

Init

Run the service as PID 1. Set this option to true to enable this feature for the service.

services:
  web:
    image: alpine:latest
    init: true

Expose port

ports:
  - "3000"
  - "8000:80"  # guest:host
# expose ports to linked services (not to host)
expose: ["3000"]

Commands and Entrypoint

# command to execute
command: bundle exec thin -p 3000
command: [bundle, exec, thin, -p, 3000]

# override the entrypoint
entrypoint: /app/start.sh
entrypoint: [php, -d, vendor/bin/phpunit]

Environment variables

# environment vars
environment:
  RACK_ENV: development
environment:
  - RACK_ENV=development

# environment vars from file
env_file: .env
env_file: [.env, .development.env]

Health check

# declare service healthy when `test` command succeed
healthcheck:
  test: ["CMD", "curl", "-f", "http://localhost"]
  interval: 1m30s
  timeout: 10s
  retries: 3
  start_period: 40s

Dependencies

# make sure `db` is alive before starting
depends_on:
  - db


# make sure `db` is healthy before starting
# and db-init completed without failure
depends_on:
db:
  condition: service_healthy
db-init:
  condition: service_completed_successfully

Volumes

volumes:
  - /var/lib/mysql # anonimous volume
  - ./host_path:/docker_container_path # bind mount

volumes:
  - type: bind
    source: ./host_path
    target: /docker_container_path
  - type: volume
    # no source. Override the previous volumes for a specific path 
    target: /node_modules

Restart

# automatically restart container
restart: unless-stopped
# always, on-failure, no (default)

User

# specifying user
user: root

# specifying both user and group with ids
user: 0:0

Commands

# Starts existing containers.
docker-compose start

# Stops running containers.
docker-compose stop

# Pauses running containers.
docker-compose pause

# Unpauses paused.
docker-compose unpause

# Lists containers.
docker-compose ps

# Builds, (re)creates, starts, and attaches to containers for a service.
docker-compose up

# Stops and removes containers.
docker-compose down

If you want to contribute leave a comment or fork the project repo:
https://github.com/maiobarbero/docker_compose_cheatsheet

Started from https://devhints.io/docker-compose

Set up Swagger in a Laravel project

Matteo Barbero — Mon, 04 Dec 2023 12:42:19 +0000

What is Swagger?

Swagger is an open-source framework to facilitate API documentation and development. It provides a standardised way to describe, document, and consume RESTful web services. Swagger makes it easier for developers and clients to understand and interact with services.

At its core, Swagger utilises a specification format known as OpenAPI (formerly Swagger Specification). OpenAPI is a language-agnostic description format used to define RESTful APIs. It allows developers to articulate the functionality of their APIs, including details such as available endpoints, request/response formats, authentication methods, and more.

Why should you use it?

One of the key advantages of Swagger is its interactive documentation, based on OpenAPI specification. This documentation not only serves as a comprehensive guide for developers but also enables clients to explore and test the API directly from a user-friendly interface. It's like having a fully documented and configured Postman inside the browser!

In summary, Swagger and OpenAPI work hand in hand to streamline the API development process, providing a standardized way to define, document, and consume RESTful APIs. This ensures that APIs are well-documented, easily understood, and straightforward to integrate, ultimately fostering collaboration between API providers and consumers.

How to use it with Laravel

There are some packages to integrate Swagger inside a Laravel, the one that I suggest to you is darkaonline/l5-swagger.

First of all you need to install it in your project with Composer
composer require "darkaonline/l5-swagger"

Then inside your .env file you need to put a variable called L5_SWAGGER_CONST_HOST, like the one below used with Sail
L5_SWAGGER_CONST_HOST=http://0.0.0.0/api/v1

We can now publish the configuration file for darkaonline/l5-swagger. Just run this command:
php artisan vendor:publish --provider "L5Swagger\L5SwaggerServiceProvider"

Now we have to set up some rules for the Swagger inside our controllers and methods and generate it.

We put our first comment inside the app/Http/Controllers/Controller.php file. This comment simply describes our API. It will be the "header" text in our page (L5_SWAGGER_CONST_HOST/api/documentation)

/**

* @OA\Info(

* version="1.0.0",

* title="MyAPI Documentation",

* description="Documentation for the public API",

* @OA\Contact(

* email="maiowebdesign@gmail.com"

* ),

* @OA\License(

* name="Apache 2.0",

* url="http://www.apache.org/licenses/LICENSE-2.0.html"

* )

* )

*

* @OA\Server(

* url=L5_SWAGGER_CONST_HOST,

* description="ArticCMS API Server"

* )



*

* @OA\Tag(

* name="myAPI",

* description="API Endpoints of MyAPI"

* )

*/

Now we can define our method in the seme way, adding a comment block before the methods inside the controllers. This is an example for a controller that get all the post inside a blog project. We can easy add our query parameters, like with_catgeories or with_author, and test them directly in the browser. We can also bind the param to an Enum, and define the response codes.

/**

* @OA\Get(

* path="/posts",

* operationId="getPostsList",

* tags={"Posts"},

* summary="Get list of posts",

* description="Returns a list of posts with optional filters.",

* @OA\Parameter(

* name="with_categories",

* in="query",

* description="Include categories associated with each post",

* @OA\Schema(type="boolean")

* ),

* @OA\Parameter(

* name="with_author",

* in="query",

* description="Include author associated with each post",

* @OA\Schema(type="boolean")

* ),

* @OA\Parameter(

* name="sort_by_date",

* in="query",

* description="Sort the posts by date",

* @OA\Schema(type="boolean")

* ),

* @OA\Parameter(

* name="lang",

* in="query",

* description="Language of the posts",

* @OA\Schema(

* type="string",

* enum=App\Enums\LocaleEnum::class,

* example="en_GB"

* )

* ),

* @OA\Parameter(

* name="status",

* in="query",

* description="Status of the posts",

* @OA\Schema(

* type="string",

* enum=App\Enums\Post\PostStatusEnum::class,

* example="draft"

* )

* ),

* @OA\Parameter(

* name="paginate",

* in="query",

* description="Number of posts per page for pagination (default: 15)",

* @OA\Schema(type="integer", default=15)

* ),

* @OA\Response(

* response=200,

* description="Successful operation",

* @OA\JsonContent(

* type="array",

* @OA\Items(ref="#/components/schemas/Post")

* )

* ),

* )

*/

It's also possible to describe our models to have an in-browser documentation of our entities. The method is always the same, just add a comment before your model class. The one below is the definition of a Post model

/**

* @OA\Schema(

* title="Post",

* description="Post model",

* @OA\Property(property="id", type="integer", example=1),

* @OA\Property(property="title", type="string", example="Sample Title"),

* @OA\Property(property="body", type="string", example="Lorem ipsum..."),

* @OA\Property(

* property="status",

* type="string",

* enum=App\Enums\Post\PostStatusEnum::class,

* example="draft",

* description="Status of the post"

* ),

* @OA\Property(

* property="language",

* type="string",

* enum=App\Enums\LocaleEnum::class,

* example="en_GB",

* description="Language of the post"

* ),

* @OA\Property(property="user_id", type="integer", example=1),

* @OA\Property(property="created_at", type="string", format="date-time"),

* @OA\Property(property="updated_at", type="string", format="date-time"),

* )

*/