DEV Community: Abdulsalam Abdulrahman (Amtech Digital)

How to Get Unlimited Free AI Coding in Your Terminal & VS Code (No Subscription Required) with OpenCode, Ollama, and DeepSeek

Abdulsalam Abdulrahman (Amtech Digital) — Thu, 05 Nov 2026 10:55:40 +0000

How to Get Unlimited Free AI Coding in Your Terminal & VS Code (No Subscription Required) with OpenCode, Ollama, and DeepSeek.

How to Use OpenCode + Ollama + DeepSeek for Free (Unlimited AI Coding)

If you have been using the open-source OpenCode AI coding agent in your terminal or VS Code, you have probably run into this frustrating error:

Error: Free usage limit reached. Free models work in OpenCode; subscribe to OpenCode Go to keep going.

While OpenCode itself is 100% free and open-source, its complimentary cloud-hosted models carry strict daily caps. Luckily, you don't need a paid subscription to bypass this. By pairing OpenCode with Ollama and running DeepSeek locally on your machine, you can unlock completely free, unlimited agentic coding.

Here is a step-by-step guide to setting it up in your terminal and IDE.

Prerequisites

OpenCode installed (via Terminal or VS Code Extension).
A computer with a decent processor. (8GB RAM can run 1.5B/7B models; 16GB+ RAM is ideal for 7B+ models).

Step 1: Install Ollama

Ollama allows you to run powerful large language models locally on your hardware.

Open your terminal and run the installation command for your operating system:
- Mac or Linux:
```
 curl -fsSL https://ollama.com | bash
```

Windows: Download the installer directly from ollama.com.
1. Verify it's working by opening a new terminal window and typing:

   ollama --version

Step 2: Download the DeepSeek Coding Model

DeepSeek offers exceptional code-generation models that rival massive commercial alternatives. We will download a coding-specific variant.

In your terminal, run the following command to download and start the model:

ollama run deepseek-coder:7b

💡 Hardware Tip: If your machine lacks a dedicated graphics card (GPU) or has less than 16GB of RAM, download the lighter, faster version instead:
ollama run deepseek-coder:1.3b

Keep this terminal window open while Ollama finishes downloading the model weights. Once it displays a >>> prompt, your local model server is officially running at http://localhost:11434.

Step 3: Configure OpenCode to Use Your Local Model

Now we just need to redirect OpenCode away from its rate-limited cloud servers and point it toward your machine.

Option A: Using OpenCode in the Terminal

When launching a new OpenCode agent session in your workspace, simply pass the local model flag targeting your Ollama instance:

opencode --model ollama/deepseek-coder:7b

(Swap 7b for 1.3b if you downloaded the smaller version).

If you want to make this your permanent default so you don't have to type the flag every time, run:

opencode config

Follow the interactive prompt to switch your primary AI provider to Local/Ollama and specify your model.

Option B: Using the OpenCode VS Code Extension

If you prefer coding inside your IDE layout, configure the extension settings directly:

Open VS Code and open your Settings (Ctrl + , on Windows/Linux or Cmd + , on macOS).
Search the settings bar for OpenCode.
Locate the Model Provider dropdown and change it from OpenCode Free Cloud to Ollama (or Local).
In the Model Name input field, type exactly: deepseek-coder:7b (or deepseek-coder:1.3b).

Conclusion

That’s it! Your AI coding agent is now completely self-hosted. OpenCode will orchestrate your files, execute terminal commands, and debug your application using DeepSeek's intelligence all powered entirely by your local machine. No limits, no subscriptions, and complete privacy for your code.

Happy hacking!

Tags: opencode deepseek ollama abdulsalamamtech agent coding

Fixing Git Push Fatal Errors: How to Soft Reset, Find Bloated Files Over 50MB, and Push Successfully

Abdulsalam Abdulrahman (Amtech Digital) — Wed, 04 Nov 2026 11:42:33 +0000

"Got hit with a 'fatal: the remote end hung up unexpectedly' error while pushing to GitHub? Here is a step-by-step guide to undoing your commit without losing work, finding files over 50MB, and fixing your configuration."

tags: "git, github, tutorial, beginners, productivity"

We have all been there. You have been coding away, everything is working perfectly, and you group your awesome progress into a clean commit. You type out git push, hit enter, and watch the progress counter climb... only to get slapped with a frustrating network termination:

Enumerating objects: 596, done.
Counting objects: 100% (596/596), done.
Delta compression using up to 8 threads
Connection to github.com closed by remote host.
send-pack: unexpected disconnect while reading sideband packet
Compressing objects: 100% (589/589), done.
fatal: the remote end hung up unexpectedly

When this happens, your local Git client is usually trying to upload a payload that is simply too large for GitHub's default HTTP buffer settings or your current network stability.
If you are stuck in this loop, do not panic and do not delete your repository. You can easily peel back your last commit, keep all your modified files intact, hunt down the oversized files causing the issue, and push your code successfully.
Here is a detailed, step-by-step walkthrough on how to fix it.

Step 1: Undo the Bloated Commit (Without Losing Your Changes)

Your first instinct might be to fear that your hard work is locked away or that you need to manually copy your code elsewhere. Git has a built-in time machine for this exact scenario: the soft reset.
Run this command in your project terminal:

git reset --soft HEAD~1

Why this works:

A --soft reset tells Git to roll back your repository history by exactly one commit (HEAD~1), but it leaves your actual workspace entirely alone.
Your files will not be changed or deleted. Instead, they will instantly return to your staged area (they will show up as green modifications when you run git status), ready for you to adjust, split up, or re-commit.

Step 2: Track Down the Culprit Files (> 50MB)

GitHub has a strict limit on file sizes. It will throw a warning for any file over 50MB and completely reject pushes containing files over 100MB. Since you are pushing hundreds of objects, there is a high probability a heavy asset, database file, or unignored package folder accidentally slipped into your staging area.
Let’s find exactly which file is blowing up your payload. Run the command that matches your operating system:

For macOS & Linux Users

Open your terminal and run this command to scan your directory while ignoring the internal .git folder:

find . -type f -size +50M ! -path '*/.git/*'

For Windows (PowerShell) Users

Open PowerShell inside your project directory and execute this script to print a clean list of files over 50MB along with their formatted sizes:

Get-ChildItem -Recurse | Where-Object { $_.Length -gt 50MB -and $_.FullName -notlike '*\.git\*' } | Select-Object FullName, @{Name="SizeMB";Expression={"{0:N2}" -f ($_.Length / 1MB)}}

Option C: Check Only What You Staged

If you want to focus exclusively on the files that were included in the commit that just failed, you can run this command to list your staged files ordered by size:

git diff --cached --name-only | xargs -I {} du -sh "{}" | grep -E '^[0-9.]*[MG]'

Step 3: Handle the Large Files

Once you have identified the files crossing the 50MB threshold, you have two primary ways to proceed depending on whether those files actually belong on your remote repository.

Scenario A: The files shouldn't be on GitHub

If the oversized file is a local database, log file, build artifact, or a dependency directory (like node_modules), you should exclude it.

Unstage the large file so Git stops trying to commit it:

git rm --cached <path/to/your/large/file>

Add it to your .gitignore file so you don't accidentally stage it again in the future:

# Open your .gitignore file and add the path or extension:
path/to/your/large/file

Scenario B: You absolutely need these files on GitHub

If the files are critical assets (like video files, datasets, or graphics) that your team needs access to, standard Git won't cut it. You need to use Git Large File Storage (LFS).

Install Git LFS on your machine (if you haven't already) and initialize it in your project:

git lfs install

Tell Git LFS to track your large file type (e.g., .psd, .zip, .mp4):

git lfs track "*.mp4"

Make sure your .gitattributes file is staged alongside your work:

git add .gitattributes

Step 4: Optimize Git Configuration & Push Again

Even after removing or tracking large files, pushing 500+ objects simultaneously can still stress a standard network connection. Let's optimize your local Git environment to handle larger transfers before you attempt your next push.

Boost the HTTP Post Buffer

By default, Git’s HTTP buffer size can be too small for massive initial pushes. Increase it to 500MB by running:

git config --global http.postBuffer 524288000

Prevent Low-Speed Timeouts

If your internet speed fluctuates or drops momentarily during the upload, GitHub might cut the line. You can eliminate the low-speed threshold timeout with these configurations:

git config --global http.lowSpeedLimit 0
git config --global http.lowSpeedTime 999999

Re-commit and Push

With your files cleaned up and your network buffers expanded, you are ready to try again. Create a fresh commit and push your code:

git add .
git commit -m "chore: optimize assets and clear heavy payloads"
git push origin <your-branch-name>

Alternative: Push in Smaller Batches

If your network continues to drop the connection even after updating your settings, your network architecture or proxy might still be struggling with a single giant push. You can bypass this by tricking Git into pushing chunks of your commits sequentially rather than all 596 objects at once.

Review your commit log history to find sequential milestones:

git log --oneline

Manually push up to a specific older commit hash first:

git push origin <COMMIT_SHA>:<BRANCH_NAME>

Once that chunk successfully reaches GitHub, push the next batch, or push the rest normally with a standard git push.

Wrapping Up

Getting disconnected mid-push can feel like hitting a brick wall, but it's almost always a combination of hidden large files and restrictive HTTP buffer defaults. By running a git reset --soft, hunting down your massive files, and updating your http.postBuffer, you can take control of your repository state without risking a single line of your code.

Have you encountered this specific Git error before?

Did increasing your buffer size solve it, or did you find a massive untracked file lurking in your directory?

Let's discuss in the comments below!

git #github #amtech #abdulsalamamtech #gitfatalerror #error

PHP2SHELL: STOP SPREADING MISINFORMATION ABOUT PHP!

Abdulsalam Abdulrahman (Amtech Digital) — Fri, 23 Oct 2026 15:06:44 +0000

🚨 PHP2SHELL: STOP SPREADING MISINFORMATION ABOUT PHP!

Recently, there's been a lot of discussion about the critical PHP2Shell vulnerabilities, and unfortunately, some people are spreading fear and misinformation.

I've seen statements suggesting that PHP is no longer secure, that developers should abandon it, or that 70% of websites have already been compromised.

Let's get the facts straight. 👇

✅ PHP2Shell is real. Two critical vulnerabilities (CVE-2026-109618 and CVE-2026-109619) were discovered in PHP's core runtime.

✅ The threat is serious. These vulnerabilities could allow attackers to execute malicious code on affected servers.

✅ PHP is not dead. Discovering vulnerabilities doesn't automatically make a programming language obsolete.

✅ 70% of websites being powered by PHP doesn't mean 70% have been hacked. There's a difference between potential exposure and confirmed exploitation.

✅ Security patches are available. The PHP team released emergency updates on October 21, 2026, addressing these vulnerabilities.

So, what should developers do?

🔹 Update affected PHP installations.

🔹 Check official security advisories.

🔹 Verify that your hosting provider has applied the necessary fixes.

🔹 Monitor your applications for suspicious activity.

🔹 Stop sharing unverified information.

💡 MY TAKE:

Every technology can experience security vulnerabilities. What matters is how vulnerabilities are discovered, addressed, and managed.

As software engineers, we should educate people with facts, not create unnecessary panic.

Don't abandon a technology because of headlines. Understand the problem, apply the fixes, and keep building securely.

📢 Before sharing the next alarming PHP headline, verify the source.

💬 What do you think about the reactions to PHP2Shell?

👨🏽‍💻 Abdulsalam Abdulrahman

Software Engineer | Tech Educator | SDG Advocate

AMTECH | @abdulsalamamtech

PHP #PHP2Shell #Cybersecurity #SoftwareEngineering #Laravel #WebDevelopment #SecureCoding #AMTECH #TechEducation #abdulsalamamtech

How to Limit Battery Charging on Ubuntu Linux (Step-by-Step)

Abdulsalam Abdulrahman (Amtech Digital) — Thu, 15 Oct 2026 10:41:30 +0000

Here is a clean, markdown-formatted guide ready to copy and paste directly onto your blog. It uses the 70% to 90% thresholds you requested as the example.

How to Limit Battery Charging on Ubuntu Linux (Step-by-Step)

Keeping your laptop plugged into a charger at 100% capacity constantly can degrade the battery over time. By setting charge thresholds, you can command your system to stop charging once it hits a healthy maximum limit (e.g., 90%) and only resume charging when the battery drops below a minimum threshold (e.g., 70%).
Here is how to set this up using TLP, the ultimate Linux power-management tool.

Step 1: Install TLP

Open your terminal (Ctrl + Alt + T) and run the following command to update your package list and install the core TLP service:

sudo apt update && sudo apt install -y tlp

Step 2: Configure Your Charge Limits

Next, you need to edit TLP's main configuration file to set your custom thresholds. Open it using the terminal's text editor:

sudo nano /etc/tlp.conf

Use your arrow keys to scroll down, or press Ctrl + W to search for THRESH.
Locate the following lines, remove the # symbol from the beginning of each line to uncomment them, and set your desired values:

START_CHARGE_THRESH_BAT0=70
STOP_CHARGE_THRESH_BAT0=90

Use code with caution.
(Note: BAT0 is the default battery name for most laptops. If you have a dual-battery laptop like a Lenovo ThinkPad, repeat this step for START_CHARGE_THRESH_BAT1 and STOP_CHARGE_THRESH_BAT1).

Save and exit the file by pressing Ctrl + S and then Ctrl + X.

Step 3: Start and Enable the TLP Service

To activate the new limits and make sure they apply every time your laptop boots up, run these three commands:

sudo tlp start
sudo systemctl enable tlp.service
sudo systemctl start tlp.service
Use code with caution.

Step 4: Verify Your Configuration

To ensure everything was configured correctly and to verify that your laptop hardware supports software-level thresholds, run the battery status command:

sudo tlp-stat -b

Use code with caution.

Look at the end of the output. It should show your new limits active:
• Charging start threshold: 70%
• Charging stop threshold: 90%

⚠️ Important Hardware Limitation

Battery thresholds rely heavily on your laptop's physical charging controller and Linux kernel support.

• This feature works flawlessly out-of-the-box on most Lenovo ThinkPads, ASUS, and Dell laptops.

• If sudo tlp-stat -b displays a message stating that charging thresholds are not supported or unsupported, your specific laptop manufacturer may require a dedicated BIOS configuration instead of software intervention.

Check my other post on How to check your Linux PC battery capacity

Follow for more content like this!

How to check your Linux PC battery capacity

Abdulsalam Abdulrahman (Amtech Digital) — Thu, 15 Oct 2026 10:32:58 +0000

Check your Linux PC battery capacity

With just one command in your terminal or command line:

sudo tlp-stat -b

Check my other post on How to Limit Battery Charging on Ubuntu Linux (Step-by-Step)

Follow for more content like this!

More tip coming soon!

Why you need to learn digital skills

Abdulsalam Abdulrahman (Amtech Digital) — Sat, 03 Oct 2026 14:58:04 +0000

Why You Need to Learn Digital Skills Today

Introduction

The world has changed. From banking and shopping to how we work, everything has gone digital. Staying relevant in today's world requires a new set of tools. Learning digital skills is no longer just an advantage; it is a necessity for survival and growth.

What Are Digital Skills?

Digital skills are the abilities required to use digital devices, communication applications, and networks to access, manage, and create information. They range from basic tasks like sending an email or using Microsoft Office, to advanced skills like building websites, analyzing data, or managing social media.

Why You Should Learn Them

The Job Market Has Shifted: Over 80% of all professional jobs now require some level of digital literacy.
Future-Proofing: Traditional jobs are evolving. Knowing tech ensures you will not be left behind as AI and automation grow.
Work Freedom: Digital skills unlock the ability to work remotely from anywhere in the world.

What to Learn & Their Direct Benefits

Digital Marketing: Helps you grow businesses or build your own brand online.
Data Analysis: Allows you to turn raw numbers into smart business decisions.
Web & App Development: Gives you the power to build websites, tools, and software.
Graphic Design & Content Creation: Enables you to visually communicate ideas and capture attention.
Cybersecurity: Teaches you how to protect valuable data and networks from online threats.

How & Where You Can Learn

You do not need an expensive college degree to get started. You can learn at your own pace through online video courses, interactive bootcamps, and hands-on practice projects.

Top Free Platforms to Start Today

Coursera & edX: Offers free access to audit real classes from universities like Harvard and Google (pay only if you want the certificate).
YouTube: The largest free library for step-by-step software and coding tutorials.
freeCodeCamp: A completely free, hands-on platform to learn coding and web development.
HubSpot Academy: Great for free inbound marketing, sales, and customer service certificates.

The Bottom Line

Your phone and laptop are more than just entertainment devices—they are your ticket to financial freedom. Spend just 30 minutes a day learning a new digital skill, and watch your career opportunities multiply.

How to deploy Next.js app to Hostinger shared hosting and alsoadd a github workflow (ci/cd)

Abdulsalam Abdulrahman (Amtech Digital) — Tue, 19 May 2026 21:28:29 +0000

How to deploy Next.js app to Hostinger shared hosting and alsoadd a github workflow (ci/cd)

You can bypass Hostinger's limitations entirely by building your application on GitHub Actions and automatically deploying the static files via FTP/SFTP. This means you do not need Node.js installed on your Hostinger account, and your local machine does not need to handle the build.

📋 Prerequisites Before Setting Up

You must first change your Next.js project to static export mode so GitHub can build it into flat HTML/CSS/JS files.

Open your next.config.mjs (or next.config.js) and add the export configuration:

   /** @type {import('next').NextConfig} */const nextConfig = {
     output: 'export',
     images: {
       unoptimized: true, // Required for static export
     },
   };
   export default nextConfig;

Commit and push this change to your repository.

🔐 Step 1: Get FTP Credentials & Add to GitHub

GitHub needs permission to upload files to your Hostinger server.

Log into your Hostinger hPanel.
Navigate to Websites > Manage > Files > FTP Accounts.
Note your FTP Host, FTP Username, and FTP Password.
Go to your repository on GitHub.
Click Settings > Secrets and variables > Actions > New repository secret.
Create the following three secrets:
- FTP_SERVER (Your Hostinger FTP Host)
- FTP_USERNAME (Your Hostinger FTP Username)
- FTP_PASSWORD (Your Hostinger FTP Password)

🚀 Step 2: Create the GitHub Actions Workflow

This workflow will trigger every time you push to your main branch. It spins up a temporary virtual environment, installs Node.js, builds your Next.js app, and uploads the out folder to Hostinger.

In the root of your local project, create a folder structure named .github/workflows/.
Inside that folder, create a file named deploy.yml.
Paste the following configuration into deploy.yml:

name: Deploy Next.js to Hostinger
on:
  push:
    branches:
      - main # Change this to 'master' if your default branch is named master
jobs:
  build-and-deploy:
    runs-on: ubuntu-latest

    steps:
      - name: Checkout Repository
        uses: actions/checkout@v4

      - name: Setup Node.js
        uses: actions/setup-node@v4
        with:
          node-level: 20
          cache: 'npm'

      - name: Install Dependencies
        run: npm ci

      - name: Build Next.js Static Site
        run: npm run build

      - name: Deploy via FTP to Hostinger
        uses: SamKirkland/FTP-Deploy-Action@v4.3.5
        with:
          server: ${{ secrets.FTP_SERVER }}
          username: ${{ secrets.FTP_USERNAME }}
          password: ${{ secrets.FTP_PASSWORD }}
          local-dir: ./out/
          server-dir: ./public_html/ 
          # Use ./public_html/subfolder/ if hosting on a subdomain

🛠️ Step 3: Trigger Your First Deployment

Save the deploy.yml file.
Commit and push the new workflow to GitHub:

   git add .github/workflows/deploy.yml next.config.mjs
   git commit -m "Add GitHub Actions CI/CD deployment workflow"
   git push origin main

Go to the Actions tab on your GitHub repository page to watch the live build progress. Once it finishes green, your site will be updated live on Hostinger.

If you hit any errors during the automated GitHub build or face issues with asset loading, let me know the error message or if you are hosting this on a subdomain so we can tweak the routing configuration.

step by step crud operation in motoko - how to store and retrieve data

Abdulsalam Abdulrahman (Amtech Digital) — Sat, 09 May 2026 15:15:43 +0000

To store 1 question and 4 options in Motoko efficiently, you should define a structured Record type to hold the data, rather than a raw Buffer. If you need to store multiple of these questions in a resizable container, you would use a Buffer to hold those records.

Here is the recommended implementation using an Actor to manage the question storage.

Define the TypesUse a stable Record type to ensure the data persists across upgrades.

motoko

type Option = Text;
type Question = {
    questionText : Text;
    options : [Option]; // Array of 4 options
    correctOptionIndex : Nat; // Index 0-3
};

Implementation Using BufferThis actor initializes with a Buffer to store multiple Question records.

motoko

import Buffer "mo:base/Buffer";
import Array "mo:base/Array";

actor QuestionManager {

    // Define the type for the question
    public type Question = {
        questionText : Text;
        options : [Text]; // Expected size 4
        correctOptionIndex : Nat; // 0, 1, 2, or 3
    };

    // Buffer is a resizable array
    let questionsBuffer = Buffer.Buffer<Question>(10);

    // Function to add a question
    public func addQuestion(q : Question) : async () {
        // Simple validation: Ensure 4 options
        if (q.options.size() == 4) {
            questionsBuffer.add(q);
        };
    };

    // Function to get all questions
    public query func getQuestions() : async [Question] {
        // Convert buffer to immutable array for returning
        return questionsBuffer.toArray();
    };

    // Function to get total question count
    public query func getCount() : async Nat {
        return questionsBuffer.size(); //
    };
}

Key Motoko Concepts

Used[Records]: { questionText : Text; ... } defines a structured object.
[Buffer]: Buffer.Buffer(10) creates a mutable, resizable container, ideal for managing lists of data on the heap.
[Array]: [Text] is a fixed-size array, perfect for the 4 options, ensuring they are immutable and easily shared.
ToArray: questionsBuffer.toArray() converts the mutable buffer into a shared, immutable array format required for canister return values.

Run and test

# Starts the replica, running in the background
dfx start --background

# Deploys your canisters to the replica and generates your candid interface. It basically deploys the fullstack application

dfx deploy

Read more...
Motoko Book
Mops Docs

best architectural patterns approach for senior Laravel developers

Abdulsalam Abdulrahman (Amtech Digital) — Mon, 04 May 2026 14:28:31 +0000

For senior Laravel developers, the best architecture focuses on modularity, testability, and separation of concerns, moving beyond basic MVC to Domain-Driven Design (DDD) or Action-based Architectures.

Key patterns include using Repositories to abstract Eloquent, Services/Actions for complex business logic, and DTOs (Data Transfer Objects) for data integrity.

Key Architectural Patterns for Senior Laravel Developers:Domain-Driven Design (DDD) / Modular Monolith: Structures code around business domains (Users, Orders) rather than technical layers (Controllers, Models), improving maintainability in large applications.

Action/Service Pattern: Encapsulates business logic into single-purpose classes (e.g., CreateOrderAction), reducing Controller bloat and promoting reusability.

Repository Pattern: Abstracts data access logic from the model. This allows swapping database implementations or caching layers without affecting business logic.

Data Transfer Objects (DTOs): Used to pass structured data between application layers, ensuring type safety and reducing reliance on associative arrays.

Event-Driven Architecture (Observer Pattern): Uses Laravel Events and Listeners to decouple side effects (e.g., sending emails, updating search indexes) from the main application flow.

Strategy Pattern: Ideal for handling varying behaviors, such as multiple payment gateways (Stripe vs. PayPal), by selecting algorithms at runtime.

Best Practices for Senior Implementation:Dependency Inversion Principle: Depend on abstractions (Interfaces) rather than concrete Eloquent models in service classes.

Leverage Laravel Service Providers: Register bindings for repositories and services in the Service Container to manage dependencies cleanly.

Avoid Over-Engineering: Start with solid Service/Action classes and adopt stricter DDD patterns as complexity grows.

Domain-Driven Design (DDD) / Modular Monolith in Laravel

Domain-Driven Design (DDD) and Modular Monoliths in Laravel shift focus from technical layers (Controllers, Models) to business capabilities. This approach is ideal for complex enterprise systems like CRMs or financial platforms where intricate business rules can easily overwhelm standard MVC structures.

Core Architectural Layers

A common way to implement DDD in Laravel is to organize the app/ directory into three primary layers:

Domain Layer: The heart of the application containing pure business logic.
Entities: Objects with a distinct, stable identity (e.g., a User or Order).
- Value Objects: Immutable objects defined by their attributes (e.g., EmailAddress, MoneyAmount).
- Aggregates: Clusters of related objects treated as a single unit, managed by an "Aggregate Root" to ensure consistency.
- Domain Events: Indicators that something significant happened in the business (e.g., OrderPlaced).
Application Layer: Orchestrates domain objects to perform specific tasks (Use Cases). It often uses DTOs (Data Transfer Objects) to move data without exposing internal models.
Infrastructure Layer: Handles technical implementation details like database persistence (Eloquent), external APIs, and mail services.

Implementing a Modular Monolith

While DDD focuses on the "what," a Modular Monolith defines the "where." It keeps everything in one codebase but enforces strict boundaries between different business areas.

Structure: Modules are often housed in a top-level src/Modules/ or app/Modules/ directory. Each module contains its own routes, controllers, models, and tests.
Encapsulation: Modules should only interact through defined interfaces or events to avoid "spaghetti" coupling.
Communication: Inter-module communication is best handled via Laravel Events and Listeners. For example, the Orders module emits an event that the Inventory module listens to for stock updates.
Tooling: Packages like nwidart/laravel-modules or InterNACHI/Modular are popular for scaffolding this structure.

Why Choose This Path?

Long-term Maintainability: Clear boundaries prevent a "god-class controller graveyard" where business rules are scattered everywhere.
Scalability: If a specific module grows too large or requires unique resources, it can be extracted into a separate microservice more easily because it is already isolated.
Business Alignment: Developers and stakeholders use a "Ubiquitous Language," ensuring the code structure directly reflects real-world business processes.

Consideration for Senior Devs: DDD has a steep learning curve and introduces significant boilerplate. For simple CRUD applications, Laravel's default MVC is usually more efficient.
Would you like to see a folder structure example or a code snippet for a Laravel Domain Action?

[1] https://medium.com
[2] https://medium.com
[3] https://ilyaskazi.medium.com
[4] https://www.youtube.com
[5] https://www.youtube.com
[6] https://spartner.software
[7] https://laracasts.com
[8] https://dev.to
[9] https://medium.com
[10] https://www.youtube.com
[11] https://medium.com
[12] https://sevalla.com
[13] https://www.iflair.com
[14] https://filamentphp.com
[15] https://ilyaskazi.medium.com
[16] https://www.youtube.com
[17] https://dev.to
[18] https://medium.com
[19] https://www.port.io

Learn more about Laravel Architecture & Design Patterns:
Laravel Best Practices: SOLID, Clean Architecture & Design Patterns

Implementing Domain-Driven Architecture in Laravel: Setup, Advantages, and Practical Use Cases

How to scale a Laravel PHP app like Facebook or Twitter (X)

Abdulsalam Abdulrahman (Amtech Digital) — Sat, 02 May 2026 13:29:15 +0000

Scaling a Laravel application to handle high traffic like Facebook or Twitter requires a shift from a single-server setup to a horizontally scaled, stateless architecture. Key strategies include using Load Balancers (AWS/DigitalOcean), Redis for caching/sessions, database read/write splitting, queueing heavy tasks, and implementing Laravel Octane for performance.

Core Scaling Strategies:

Horizontal Scaling (Load Balancing): Distribute traffic across multiple application servers using a load balancer. Ensure the application is stateless (e.g., storing sessions in Redis/database rather than locally).

Database Optimization:

Read/Write Splitting: Use a primary database for writes and multiple replicas for reads.

You must have actual database replication (Master-Slave) set up at the server level (e.g., via AWS RDS , DigitalOcean, or manual MySQL configuration). Laravel does not perform the data synchronization itself; it only directs the traffic.

'mysql' => [
    'driver' => 'mysql',
    'read' => [
        'host' => [
            '192.168.1.1', // Replica 1
            '192.168.1.2', // Replica 2
        ],
    ],
    'write' => [
        'host' => [
            '192.168.1.3', // Primary
        ],
    ],
    'sticky'    => true, // Essential for data consistency
    'driver'    => 'mysql',
    'database'  => env('DB_DATABASE', 'forge'),
    'username'  => env('DB_USERNAME', 'forge'),
    'password'  => env('DB_PASSWORD', ''),
    // ... other options
],

Laravel read and write docs

How to scale Laravel: beyond the basics (Advanced Laravel Scaling)

How to Build a High-Performance, Scalable Laravel App

Key Considerations

Sticky Connections: Setting 'sticky' => true ensures that once a write operation occurs during a request, all subsequent read operations for that same request use the write connection. This prevents issues where a user saves data but cannot immediately see it due to replication lag on the read replicas.
Load Balancing: Laravel will automatically choose a random host from the read array for each request, effectively load balancing your database traffic.
Replication Setup: Laravel manages the application-level routing of queries, but you must independently configure your database servers (like MySQL or PostgreSQL) for Master-Slave replication so that data from the primary node is synced to the replicas.
Model Specificity: If you need a specific Eloquent model to always use a particular connection (other than the default), you can define the $connection property directly in the model class.
Transaction Handling: Database transactions in Laravel automatically use the write connection to ensure atomicity and consistency.

Indexing & Query Optimization: Add indexes for common queries, avoid table scans, and use eager loading (e.g., with()) to prevent N+1 query issues.

Caching Strategy:

Redis: Use Redis for caching, session management, and queue management to reduce database load.

Cache Data: Cache expensive queries, API responses, and frequently accessed data.

Laravel Caching: Use php artisan config:cache and php artisan route:cache.

Queues and Asynchronous Processing:

Offload slow tasks (e.g., sending emails, processing images) to queues using Redis or Amazon SQS.

Content and Asset Management:

CDN: Use a Content Delivery Network (e.g., Cloudflare, CloudFront) to serve images, CSS, and JavaScript.

Cloud Storage: Use Amazon S3 or similar services for storing user-uploaded media instead of local storage.

High Performance Engine:

Laravel Octane: Utilize Octane with Swoole or RoadRunner to keep the application in memory, significantly increasing request throughput.

Infrastructure Requirements:

Stateless Apps: Ensure FILESYSTEM_DRIVER is set to s3 or similar.Database Scaling: For massive scale, look beyond master-slave replication into partitioning or adopting NoSQL for specific use cases.

Monitoring: Implement tools like Laravel Telescope or third-party solutions to monitor performance.

Secure Your API with Modern Authentication

Laravel Sanctum: Perfect for SPAs, mobile apps, and token-based authentication.
Laravel Passport: A full OAuth2 server implementation for more complex needs.

Smart API Versioning

URL Versioning: /api/v1/users
Header Versioning: Using a custom Accept header.

A Multi-Layered Testing Strategy

Unit Tests: Verify small, isolated pieces of code.
Feature Tests: Test a complete feature from end to end.
Browser Tests: Use Laravel Dusk to automate user interactions in a real browser.

Modern Deployment and Monitoring

Error Tracking: Use services like Sentry or Bugsnag.
Performance Monitoring: Tools like New Relic or Datadog provide deep insights.
Logging: Centralized logging helps you debug issues quickly.

Building a high-performance, scalable Laravel application is a continuous journey. It begins with a solid architectural foundation. Then, it requires constant optimization, robust API design, and automated quality assurance. These are not just best practices; they are essential for success. Read more from WebMob

Resolving GitHub conflict: merge, rebase and fast-forward only

Abdulsalam Abdulrahman (Amtech Digital) — Wed, 19 Nov 2025 14:02:47 +0000

Difference between:

hint: git config pull.rebase false # merge
hint: git config pull.rebase true # rebase
hint: git config pull.ff only #

I'll explain the three git pull strategies and help you choose the best one for your situation:

Updated todo list

Three Git Pull Strategies Explained

pull.rebase false (Merge Strategy) 🔀

git config pull.rebase false
What it does:

Creates a merge commit when pulling changes
Combines your local commits with remote commits
Preserves full history of both branches
Visual:

Before pull: Local: A — B — C Remote: A — X — YAfter pull: A — B — C — M (merge commit) \ / X — Y
Pros:
✅ Full history preserved
✅ Easy to see when integrations happened
✅ Safe for collaborative work

Cons:
❌ Messy commit graph with many merge commits
❌ Harder to read git log

pull.rebase true (Rebase Strategy) 📚

git config pull.rebase true
What it does:

Replays your local commits on top of remote changes
Creates a linear history (no merge commits)
Rewrites commit history
Visual:

Before pull: Local: A — B — C Remote: A — X — YAfter pull: A — X — Y — B' — C'
Pros:
✅ Clean, linear history
✅ Easier to read and understand flow
✅ No merge commit clutter

Cons:
❌ Rewrites history (changes commit hashes)
❌ Can cause issues if commits are already pushed
⚠️ Slightly risky if you don't understand rebase

pull.ff only (Fast-Forward Only) ⚡

git config pull.ff only
What it does:

Only allows fast-forward merges (linear history without new commits)
Rejects any pull that would require a merge or rebase
Forces you to manually resolve conflicts
Visual:

✅ ALLOWED (fast-forward):

Local: A — B — C
Remote: A — B — C — X — Y
Result: A — B — C — X — Y❌

REJECTED (non-fast-forward):
Local:  A — B — C
Remote: A — X — Y  → Pull fails! You must rebase or merge manually

Pros:
✅ Guarantees clean, linear history
✅ Forces intentional conflict resolution
✅ No accidental messy merges

Cons:
❌ Very strict; many pulls will fail
❌ Requires extra manual steps
❌ Not ideal for team collaboration

📊 Comparison Table
Feature merge rebase ff only
History shape Non-linear (branchy) Linear Linear
Merge commits

✅ Created
❌ None

❌ None

Rewrites commits

❌ No

✅ Yes Depends

Easy to read git log

❌ No

✅ Yes
✅ Yes

Safe for shared branches

✅ Yes
❌ No

✅ Yes

Risk of conflicts Low Medium High
Best for teams

✅ Yes
❌ Not really

✅ Sometimes

🎯 Recommendation for Your Situation
For resolving your current merge conflict in api-docs.json:

Use pull.rebase false (Merge) ← RECOMMENDED

git config pull.rebase false
Why?

✅ You're working in a team repo (hngprojects/HNG-Portal-BE)
✅ Your commits are likely already shared/pushed
✅ Safe - doesn't rewrite history
✅ Preserves the full narrative of changes
✅ Standard practice for collaborative projects

Your next steps:

1. Resolve the conflict manually in api-docs.json (You need to combine the auth endpoints + job-types endpoints)

2. Stage the resolved filegit add storage/api-docs/api-docs.json

3. Complete the mergegit commit -m "Merge: resolve conflicts in api-docs.json - combine auth and job-types endpoints"# 4. Push to remotegit push origin feature/add-job-types

Would you like me to:

✅ Help you resolve the conflicts in the file manually?
📝 Generate a merged version of api-docs.json with both sets of endpoints?
🔍 Review what content exists in each branch first?
Let me know which you prefer!

Learn more about git rebase

Building a medical emergency AI agent boot using A2A protocol for HNG backend stage.

Abdulsalam Abdulrahman (Amtech Digital) — Mon, 03 Nov 2025 23:32:30 +0000

Building a medical emergency AI agent boot using A2A protocol for HNG backend stage.

Motivation:

Building Emergent AI and AI Agent that answers medical emergency related questions and give tips on what to do based on described emergency.

It is a difficult thing to exactly know what to do in different emergency situation, the data is already out their is just to have the exact information of what to do on different situation before help arise can save lives and property.

I wanted to be able to have an AI agent that can easily guide someone through this situation.

Tech stack:

PHP/Laravel
Laragent library
Railway

In short Emergent is a chat bot that answers #medical #emergency related questions & help with tips!

System design:

User Message (Telex)
    ↓
JSON-RPC 2.0 Request
    ↓
Railway App Service (NGINX Server)
    ↓
Laravel Framework & API
    ↓
Gemini AI Agent
    ↓
Format & Return
    ↓
A2A Response
    ↓
Telex.im Display

💻 Building the Agent:

I set up Laravel
Install Laragent
Register my API KEY on Gemini
Add the API_KEY to my .env file
I test the agent ability
I Implement the A2A Protocol
I test it again
I push to GitHub and deployed to Railway
Result

The challenges:

I wasn't able to understand how a2a works. I go through the documentation and articles multiple times.
I wast not getting the right message. I went on to test and debug the codebase again.
Other AI model I used wasn't working. I tried multiple LLM before finally using Gemini.
Formatting the response and error. I created different methods to format the responses for error and success.
I have production error while deploying to Railway. I changed the PHP version from 8.2 to 8.3.
I wasn't able to integrate it with telex. An article and step by step guide was later sent to the slack group that is want I used to be able to setup my Agent.

Performance:

Response agent api time <500ms
Total response time ~2-3s
Uptime 99.9%
Success rate 99%

Conclusion:

Building Emergent AI Agent allow people to be able to seek emergency tips before help arrive and I was able to work on something extra-ordinary using AI and combining it with a technology new to me Telex A2A protocol.

Connect with me:

GitHub: https://github.com/abdulsalamamtech/hng-stage-3
X (Twitter): https://x.com/abdulsalamtech
Linkedin: https://linkedin.com/in/abdulsalamamtech
Facebook: https://facebook.com/abdulsalamamtech