DEV Community: Abdulsalam Abdulrahman (Amtech Digital)

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

Different type of action to take on delete in Laravel database migration

Abdulsalam Abdulrahman (Amtech Digital) — Wed, 29 Oct 2025 11:01:36 +0000

Different type of action to take on delete in Laravel database migration.

When defining a foreign key in a Laravel migration, the onDelete method determines what happens to the child records when the parent record is deleted. This allows you to manage data integrity at the database level.

Here are the different types of onDelete actions you can use:

cascade

The CASCADE action will automatically delete all child records when their parent record is deleted. This is useful for "has many" relationships where the child records are meaningless without the parent.

Example: If a user is deleted, all of their posts are also deleted.

Migration code:

$table->foreignId('user_id')->constrained()->cascadeOnDelete();

Migration code:


$table->foreign('user_id')
      ->references('id')->on('users')
      ->onDelete('cascade');

set null

The SET NULL action will set the foreign key on all child records to null when the parent record is deleted. This is useful for optional relationships where the child record can still exist without the parent.

Example: When a user is deleted, the user_id on their posts is set to null, allowing the posts to remain without an author. Note: Requirement: The foreign key column must be set as nullable() in the migration.

Migration code:


$table->foreignId('user_id')->nullable()->constrained()->nullOnDelete();

Migration code:

$table->unsignedBigInteger('user_id')->nullable();
$table->foreign('user_id')
      ->references('id')->on('users')
      ->onDelete('set null');

restrict

The RESTRICT action prevents the parent record from being deleted as long as there are still child records referencing it. This is the default behavior if no onDelete action is specified.

Example: If a category has associated products, you cannot delete the category until all products have been re-assigned or deleted.

Migration code: No onDelete method is called.


$table->foreignId('category_id')->constrained();

# OR

$table->foreign('category_id')
      ->references('id')->on('categories')
      ->onDelete('restrict');

no action

The NO ACTION action is similar to RESTRICT. It defers the integrity check until the end of the transaction, but in practice, most database engines implement it the same way as RESTRICT.

Migration code: You can explicitly add this, though RESTRICT or no action is sufficient.


$table->foreign('user_id')
      ->references('id')->on('users')
      ->onDelete('no action');

Choosing the right onDelete action

Scenario	Action	Example
Delete all child records	cascade	Deleting a user should also delete all of their comments.
Keep child records and unset the foreign key	set null	Deleting an author should keep their articles, with the author field becoming blank.
Prevent deletion until child records are removed	restrict	You cannot delete a product category if products are still assigned to it.

Note: This is also similar to on update.

Have a nice day!

Deloy Next or React App to VPS

Abdulsalam Abdulrahman (Amtech Digital) — Sat, 22 Mar 2025 20:55:28 +0000

Step by Step how to deploy next or react application to vps

A. Login to your VPS

 ssh user@hostname

B. Generate SSH public key and add it to your GitHub project

cat ~/.ssh/id_rsa.pub

C. Clone the project to your VPS

clone git@github.com:username/project.git
cd project

D. Install all necessary packages

npm install
npm run build
npm install pm2 --save-dev
npx pm2 start npm --name my-project -- start -- --port=3001
npx pm2 restart my-project
npx pm2 save

Sometime this work's for vite application

npx pm2 start npm --name app-name -- run dev -- --port=3001
npx pm2 save
npx pm2 status

Use this on CD like GitHub action

npx pm2 restart app-name
npx pm2 save

E. Visit the application on the provided port

https://hostname:3001

Congratulations Your Website is live!

Note: There are some necessary adjustments you need to make based on the type of OS and application on the VPS.

@abdulsalamamtech #vps #deploy #next #react