Forem: Mike Birhanu

🌍 Stop Timezone Chaos in Your Business App: A Laravel Developer’s Guide To Setup User TimeZone Based Carbon Usage

Mike Birhanu — Sun, 18 May 2025 20:09:32 +0000

Timezones are more than just a technical nuisance — they're a real threat to global businesses. Missed meetings, broken calendar exports, and daylight saving errors can cost you clients, trust, and time.

In this post, I’ll show you how I built a timezone conversion tool in Laravel that makes handling multiple timezones easy — even when your users span from Tokyo to Toronto.

Let’s dive in.

🧩 The Problem Every Global Business Faces

Imagine this:

A user in Tokyo schedules a meeting at 2 PM local time.

But someone in New York shows up at 1 AM because the app didn’t convert it right. 💀

Or worse:

Calendar exports show incorrect times
Daylight Saving Time changes break everything twice a year
Manual conversions lead to bugs, missed events, and angry customers

Sound familiar? You're not alone.

That’s why I built a simple but powerful Laravel timezone handler package — designed to solve these problems once and for all.

🔧 Step 1: Get Started Fast With My Base Code

Why reinvent the wheel?

git clone https://github.com/codewithmikee/laravel-timezone-handler

This repo includes:

A pre-built UserTimeZoneHandler class
Working demo UI (/timezone-converter)
Unit tests (for DST and edge cases)
Ready-to-use methods for both static and instance-based conversions

You can start using it in minutes — no need to write everything from scratch.

⚙️ Step 2: Use Magic Methods That Just Work

Convert Anywhere → UTC (Static Usage)

Perfect for background jobs or APIs where you don’t have a logged-in user:

$utcTime = UserTimeZoneHandler::toUtc('2023-01-01 14:00', 'Asia/Tokyo');

Instance Mode for Logged-In Users

For apps with user-specific timezones:

$handler = new UserTimeZoneHandler($user->timezone);
$localTime = $handler->toUserTimeZone($event->start_time);

Now every conversion respects the user’s current location — no matter where they are.

⚠️ Step 3: Don’t Make My Carbon Mistake

I wasted hours debugging a failing test until I realized:

Laravel extends Carbon differently!

Always use:

use Illuminate\Support\Carbon;

Not Carbon\Carbon.

It’s an easy fix — but one that saves you from weird date parsing bugs later.

🛠️ Step 4: Customize It for Your Product

Need to support Zoom, Google Calendar, or your own custom export format?

Just add a new formatter:

'zoom' => $utcTime->format('Ymd\THis\Z')

Want to convert working hours between two offices?

$converted = UserTimeZoneHandler::convertTimeRanges(
    $businessHours,
    'America/Chicago',
    'Europe/Paris'
);

This makes it perfect for:

Scheduling tools
Remote team planners
Booking systems
Customer-facing dashboards

🚀 Step 5: Launch & Test Instantly

Run the server:

php artisan serve

Then visit:

http://localhost:8000/timezone-converter

Try converting dates across different timezones and see how it handles:

DST changes
Custom formats
Multiple inputs

You’ll be amazed how smoothly it works.

✅ Why This Matters for Your Business

This isn’t just a developer tool — it’s a business enabler.

By handling timezones correctly, you ensure:

Fewer customer complaints about scheduling
Accurate calendar integrations
Better international UX
Reduced support tickets during DST changes

And best of all?

It’s open-source, so you can clone it, tweak it, and make it your own — without bloating your app with heavy libraries.

📦 Ready to Try It?

👉 Clone the repo today:

GitHub - codewithmikee/laravel-timezone-handler

Drop a ⭐ if it helped you avoid timezone chaos — and let me know how you’re using it in your app!

📣 Got Questions?

Leave a comment below or reach out — happy to help!

Laravel #PHP #Timezones #SaaS #DevOps #WebDevelopment #OpenSource #BusinessTools #Productivity

Timezones Got You Down? Build a Laravel Converter That Just Works

Mike Birhanu — Sat, 17 May 2025 20:14:59 +0000

The Problem We All Face

⏰ Your user in Tokyo picks 2 PM → New York sees 1 AM 💀

📅 Calendar exports show wrong times

🌍 DST changes break everything

Here’s how I built a converter that handles all this – and how you can clone it.

Step 1: Steal My Base Code

git clone https://github.com/codewithmikee/laravel-timezone-handler

Why start from scratch? This includes:

Pre-built service class
Working demo UI
Passing tests (mostly 😉)

Step 2: The Magic Methods

Convert Anywhere → UTC

// Static call (no user context)  
$utcTime = UserTimeZoneHandler::toUtc(  
    '2023-01-01 14:00',   
    'Asia/Tokyo'  
);

User-Friendly Instance Mode

// In controller  
$handler = new UserTimeZoneHandler($user->timezone);  

// All conversions use the user’s zone  
$localTime = $handler->toUserTimeZone($event->start_time);

Step 3: Avoid My Carbon Mistake

I wasted hours on this failed test:

public function testGoogleFormatting() {  
    $time = Carbon::parse(...); // Fails!  
}

Why? Laravel extends Carbon. Always use:

use Illuminate\Support\Carbon; // Not Carbon\Carbon!

Step 4: Add Your Secret Sauce

New Calendar Provider?

// Add to formatForProvider()  
'zoom' => $utcTime->format('Ymd\THis\Z')

Custom Time Ranges

$converted = UserTimeZoneHandler::convertTimeRanges(  
    $businessHours,  
    'America/Chicago',  
    'Europe/Paris'  
);

Step 5: Launch Your Demo

php artisan serve

Visit http://localhost:8000/timezone-converter to see:

Why This Works

✅ Handles 597 timezones (including weird ones like Australia/Lord_Howe)
✅ Tests cover DST/edge cases
✅ No hidden dependencies

Clone & Customize:

github.com/codewithmikee/laravel-timezone-handler

Build Your Own Laravel API Boilerplate (with Sanctum, Traits & Automation)

Mike Birhanu — Sat, 17 May 2025 18:41:41 +0000

A step-by-step guide to creating a scalable, maintainable Laravel API starter—using real code, real repos, and real-world patterns.

Why This Guide?

Consistent API responses (no more frontend confusion)
Reusable traits (DRY, testable code)
Extendable base controllers (easy to scale)
Built-in authentication (Sanctum)
Automated scaffolding (Artisan commands)
Repo links for every step

1️⃣ Project Setup: Start Clean

a) Create a new Laravel project:

composer create-project laravel/laravel my-api
cd my-api

Laravel Installation Docs

b) Add Sanctum for API auth:

composer require laravel/sanctum
php artisan vendor:publish --provider="Laravel\Sanctum\SanctumServiceProvider"
php artisan migrate

Sanctum Docs

c) Set up your API routes:

Edit routes/api.php and use the auth:sanctum middleware for protected endpoints:

Route::middleware('auth:sanctum')->get('/user', fn(Request $request) => $request->user());

2️⃣ Traits: The Secret to DRY, Consistent APIs

a) HandlesApiResponse

Standardize every response—success or error.

View on GitHub

// app/Concerns/HandlesApiResponse.php
trait HandlesApiResponse
{
    public function respondSuccess($data = null, string $message = '', int $status = 200)
    {
        return response()->json([
            'success' => true,
            'data' => $data,
            'message' => $message,
            'errors' => null
        ], $status);
    }

    public function respondError(string $message, int $code = 422, $errors = null)
    {
        return response()->json([
            'success' => false,
            'data' => null,
            'message' => $message,
            'errors' => $errors
        ], $code);
    }
}

b) HandlesValidation

Centralize validation logic.

View on GitHub

// app/Concerns/HandlesValidation.php
trait HandlesValidation
{
    public function validateRequest(Request $request, array $rules)
    {
        return $request->validate($rules);
    }
}

Usage Example:

class UserController extends BaseApiController
{
    public function store(Request $request)
    {
        $data = $this->validateRequest($request, [
            'email' => 'required|email|unique:users'
        ]);
        return $this->respondSuccess(User::create($data), 'User created', 201);
    }
}

3️⃣ Base Controllers: Your API's Foundation

a) BaseApiController

Centralize traits and error handling.

View on GitHub

class BaseApiController extends Controller
{
    use HandlesApiResponse, HandlesValidation;

    public function handleRequest(callable $action, string $successMessage)
    {
        try {
            $result = $action();
            return $this->respondSuccess($result, $successMessage);
        } catch (Throwable $e) {
            return $this->respondError($e->getMessage());
        }
    }
}

b) ProtectedApiController

Auto-protect endpoints with Sanctum.

View on GitHub

class ProtectedApiController extends BaseApiController
{
    public function __construct()
    {
        $this->middleware('auth:sanctum');
    }
}

Usage Example:

ProfileController Example

class ProfileController extends ProtectedApiController
{
    public function index()
    {
        return $this->respondSuccess(auth()->user(), 'Profile loaded');
    }
}

4️⃣ Automate with Artisan: No More Boilerplate

Create a custom command to scaffold controllers, requests, and resources:

php artisan make:api-resource Post

See Implementation

This generates:

PostController
PostResource
StorePostRequest / UpdatePostRequest
PostPolicy

5️⃣ Response Standards: Make Frontend Happy

Success:

{
    "success": true,
    "data": { "id": 1, "name": "John" },
    "message": "User loaded",
    "errors": null
}

Error:

{
    "success": false,
    "data": null,
    "message": "Validation failed",
    "errors": { "email": ["Invalid email"] }
}

6️⃣ Your Next Steps

Clone the boilerplate or this variant.
Run php artisan serve.
Build your first endpoint in minutes.
Try the challenge: Add a DELETE /posts/{id} endpoint with ownership checks (solution here).

Why This Works

No more spaghetti code: Traits and base controllers keep things DRY and testable.
Frontend-friendly: Predictable, consistent responses.
Easy to extend: Add features without rewriting core logic.
Battle-tested: Used in real projects (see repo stars & issues).

References & Further Reading

Ready to build? Fork, clone, and make it yours!

Questions? Open an issue on the repo or reach out to the community.