DEV Community: Mahek Patel

The Founder Question I’m Asking More Often: Does This Need My Attention or Just My Approval?

Mahek Patel — Thu, 03 Sep 2026 06:29:06 +0000

Running a software business has taught me that one of the easiest ways to lose focus is to say yes to everything.

A client needs a small change.
Someone needs an approval.
A project has an urgent issue.
A new opportunity appears.
A developer needs help.

Individually, none of these feels like a big interruption.

But together, they can consume an entire day.

So lately I’ve started asking myself one simple question:

Does this actually need my attention, or does it just need my approval?

There’s a big difference.

Some problems genuinely need me to sit down, understand the technical or business context, and decide.

Others only need:

A clear process
Better delegation
A quick approval
Someone else to take ownership

As a developer, it’s tempting to jump into every technical problem myself.

As a founder, I’m learning that this doesn’t always help the business.

My job isn’t only to solve problems.

It’s also to build a system where not every problem automatically becomes my problem.

Still learning this one.

I Built Hydration Buddy: A Floating Hydration Companion for Windows

Mahek Patel — Wed, 02 Sep 2026 06:57:02 +0000

I spend long hours working on a computer, and one simple thing I regularly forget is drinking enough water.

Most hydration apps rely on notifications. The problem? Notifications are very easy to dismiss.

So I started building Hydration Buddy: a lightweight Windows app designed to stay visible without constantly interrupting your workflow.

What it does

Tracks daily water intake
Shows your daily hydration progress
Gives gentle reminders
Lets you quickly log water
Includes a small floating companion that stays on screen
Keeps the experience lightweight and simple

Why I built it

The idea wasn't to build another notification app.

I wanted something that could quietly stay present while I'm coding or working and make the habit harder to forget.

Hydration Buddy is currently in beta, so I'm still testing the experience and improving it based on real user feedback.

🎁 The first 25 beta users get free lifetime access.

You can try it here:

https://hydrationbuddy.patelmahek.in/

If you test it, I'd especially love feedback on:

The floating companion
Reminder experience
Ease of logging water
Features you'd like to see next

I'm building this in public, so I'll also share some of the technical decisions, mistakes, and improvements as the product evolves.

10 Best Practices for Laravel API Development

Mahek Patel — Wed, 10 Sep 2025 16:38:57 +0000

Laravel is one of the most popular PHP frameworks for creating robust web applications and APIs. Its expressive syntax, built-in tools, and strong ecosystem provide everything needed to develop scalable RESTful APIs.

But writing an API that just works isn’t enough. To ensure performance, security, maintainability, and developer experience, you need to follow best practices. In this article, we’ll walk through the 10 best practices for Laravel API development.

1. Use Resourceful Routing

Laravel makes it easy to define RESTful routes with Route::apiResource(). Instead of manually writing each route, use resourceful routing to keep your code clean and consistent.

Route::apiResource('posts', PostController::class);

This provides standard endpoints (index, show, store, update, destroy) that follow REST conventions.

2. Validate Requests with Form Requests

Never trust client input. Laravel’s Form Request Validation helps you centralize validation rules and authorization logic.

class StorePostRequest extends FormRequest {
    public function rules() {
        return [
            'title' => 'required|string|max:255',
            'body' => 'required|string',
        ];
    }
}

Using form requests makes your controllers cleaner and ensures consistent validation.

3. Use API Resources (Transformers)

Instead of directly returning models, use API Resources to control the shape of your JSON response.

class PostResource extends JsonResource {
    public function toArray($request) {
        return [
            'id' => $this->id,
            'title' => $this->title,
            'published_at' => $this->created_at->toDateString(),
        ];
    }
}

This keeps your responses consistent and avoids exposing sensitive fields.

4. Implement Authentication & Authorization

APIs must be secure. Use Laravel Sanctum or Laravel Passport for token-based authentication.

Sanctum → lightweight, for SPAs or mobile apps.
Passport → full OAuth2 server, for complex use cases.

Additionally, utilize policies and gates to implement fine-grained authorization.

5. Handle Errors Gracefully

Your API should provide meaningful error responses. Use Laravel’s exception handler to deliver standardized JSON error messages.

return response()->json([
    'error' => 'Resource not found',
], 404);

Stick to proper HTTP status codes (400, 401, 403, 404, 422, 500) for clarity.

6. Paginate Responses

Large datasets can slow down APIs. Laravel makes pagination easy:

return PostResource::collection(Post::paginate(10));

This not only improves performance but also gives clients structured pagination metadata.

7. Use Caching for Performance

For heavy APIs, caching reduces load times and database queries. Laravel provides drivers like Redis and Memcached.

$posts = Cache::remember('posts', 60, function () {
    return Post::all();
});

Cache wisely—especially for expensive queries and frequently accessed data.

8. Version Your API

Always version your APIs (/api/v1/posts) to prevent breaking existing clients when making changes.

Route::prefix('v1')->group(function () {
    Route::apiResource('posts', PostController::class);
});

This ensures smooth upgrades without disrupting existing consumers.

9. Write Tests for Your API

Testing ensures reliability. Use Laravel’s built-in HTTP Tests to verify endpoints.

public function test_can_fetch_posts() {
    $response = $this->getJson('/api/posts');
    $response->assertStatus(200);
}

Automated testing catches bugs early and keeps your API stable.

10. Document Your API

Good documentation improves developer experience. Tools like Laravel OpenAPI/Swagger or scribe help you generate interactive API docs.

Clear documentation makes it easier for frontend teams, third-party developers, and even your future self.

Final Thoughts

Building a Laravel API is straightforward, but making it scalable, secure, and developer-friendly requires discipline.

By following these best practices—resourceful routing, validation, API resources, authentication, error handling, pagination, caching, versioning, testing, and documentation—you’ll be on your way to building production-ready APIs that developers love to work with.

What’s your go-to Laravel API best practice? Share it in the comments!