DEV Community: Abdulsalam Abdulrahman (Amtech Digital)

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.

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

A comprehensive guide on how to deploy laravel application to vps, using github action, ssh key, server permissions and more.

Abdulsalam Abdulrahman (Amtech Digital) — Wed, 05 Mar 2025 23:01:14 +0000

Comprehensive Laravel Deployment Guide with GitHub Actions and VPS

Hostinger

link to hostinger blog post on how to deploy laravel on vps

Prerequisites

A GitHub repository with your Laravel project
A VPS (Virtual Private Server) running Linux (Ubuntu recommended)
SSH access to your VPS
Basic understanding of Git, Laravel, and terminal commands

Step 1: Prepare Your Local Development Environment

1.1 Ensure Your Laravel Project is Ready

Make sure your project is in a GitHub repository
Check your .gitignore file to exclude unnecessary files:

/node_modules
/public/hot
/public/storage
/storage/*.key
/vendor
.env
.env.backup
.phpunit.result_cache

1.2 Prepare Environment Configuration

Create a .env.production file with production-specific configurations
Ensure sensitive information is not hardcoded

Step 2: Set Up SSH Keys for GitHub Actions

2.1 Generate SSH Keys on Your Local Machine

# Generate a new SSH key specifically for GitHub Actions
ssh-keygen -t ed25519 -C "github-actions-deployment"

# Save the key in a specific location, e.g., ~/.ssh/github_actions_key
# Do NOT use a passphrase for automated deployment

2.2 Set Up SSH on VPS

Connect to your VPS via SSH

ssh root@your_vps_ip

Create a deployment user

# Create a new user for deployments
adduser deployer

# Give sudo privileges (use carefully)
usermod -aG sudo deployer

# Switch to deployer user
su - deployer

Set up SSH directory for the deployer user

mkdir -p ~/.ssh
chmod 700 ~/.ssh
touch ~/.ssh/authorized_keys
chmod 600 ~/.ssh/authorized_keys

2.3 Configure GitHub Repository Secrets

Go to your GitHub repository
Navigate to Settings > Secrets and variables > Actions
Add the following secrets:
- VPS_HOST: Your VPS IP address
- VPS_PORT: SSH port (default 22)
- VPS_USER: deployer
- SSH_PRIVATE_KEY: Content of the private key generated in step 2.1
- SERVER_DESTINATION: Path on server (e.g., /home/deployer/your-app)
- DEPLOYMENT_ENV_FILE: Base64 encoded production .env file contents

Step 3: Prepare VPS for Laravel Deployment *[Skip to step 4 if you are using any VPS panel]

3.1 Install Required Software

# Update system
sudo apt update && sudo apt upgrade -y

# Install PHP and extensions
sudo apt install -y php8.2-fpm php8.2-cli php8.2-common php8.2-mysql php8.2-zip php8.2-gd php8.2-mbstring php8.2-curl php8.2-xml php8.2-bcmath

# Install Composer
curl -sS https://getcomposer.org/installer | php
sudo mv composer.phar /usr/local/bin/composer

# Install Nginx
sudo apt install -y nginx

# Install MySQL (if not already installed)
sudo apt install -y mysql-server

# Install Node.js and NPM
curl -fsSL https://deb.nodesource.com/setup_lts.x | sudo -E bash -
sudo apt install -y nodejs

3.2 Configure Nginx

Create Nginx configuration

server {
    listen 80;
    server_name your-domain.com;
    root /home/deployer/your-app/public;

    index index.php;

    charset utf-8;

    location / {
        try_files $uri $uri/ /index.php?$query_string;
    }

    location = /favicon.ico { access_log off; log_not_found off; }
    location = /robots.txt  { access_log off; log_not_found off; }

    error_page 404 /index.php;

    location ~ \.php$ {
        fastcgi_pass unix:/var/run/php/php8.2-fpm.sock;
        fastcgi_index index.php;
        fastcgi_param SCRIPT_FILENAME $realpath_root$fastcgi_script_name;
        include fastcgi_params;
    }

    location ~ /\.(?!well-known).* {
        deny all;
    }
}

Enable configuration

sudo ln -s /etc/nginx/sites-available/your-app /etc/nginx/sites-enabled/
sudo nginx -t
sudo systemctl restart nginx

Step 4: Create GitHub Actions Workflow *[Continue from here if you are using VPS panel on your server]

4.1 Create Workflow File

Create .github/workflows/laravel-deploy.yml:

name: Laravel Deployment

on:
  push:
    branches: [ "main" ]

jobs:
  deploy:
    runs-on: ubuntu-latest

    steps:
    - uses: actions/checkout@v3

    - name: Setup PHP
      uses: shivammathur/setup-php@v2
      with:
        php-version: '8.2'
        extensions: mbstring, bcmath, zip

    - name: Install Composer Dependencies
      run: composer install -q --no-ansi --no-interaction --no-scripts --no-progress --prefer-dist

    - name: Install NPM Dependencies
      run: npm install

    - name: Build Frontend
      run: npm run build

    - name: Prepare Environment File
      run: |
        echo "${{ secrets.DEPLOYMENT_ENV_FILE }}" | base64 --decode > .env

    - name: Deploy to VPS
      uses: appleboy/ssh-action@master
      with:
        host: ${{ secrets.VPS_HOST }}
        username: ${{ secrets.VPS_USER }}
        key: ${{ secrets.SSH_PRIVATE_KEY }}
        script: |
          cd ${{ secrets.SERVER_DESTINATION }}
          git pull origin main
          composer install --no-interaction
          php artisan migrate --force
          php artisan config:clear
          php artisan cache:clear
          npm install
          npm run build
          sudo systemctl restart nginx

Step 5: Final VPS Configuration

5.1 Set Up Git on VPS

cd /home/deployer/your-app
git init
git remote add origin https://github.com/your-username/your-repo.git

5.2 Set Permissions

sudo chown -R deployer:deployer /home/deployer/your-app
sudo chmod -R 755 /home/deployer/your-app
sudo chmod -R 775 /home/deployer/your-app/storage
sudo chmod -R 775 /home/deployer/your-app/bootstrap/cache

Step 6: Database Setup

# Create MySQL database
sudo mysql
CREATE DATABASE your_database_name;
CREATE USER 'your_username'@'localhost' IDENTIFIED BY 'your_password';
GRANT ALL PRIVILEGES ON your_database_name.* TO 'your_username'@'localhost';
FLUSH PRIVILEGES;
EXIT;

Troubleshooting Tips

Check GitHub Actions logs for specific errors
Verify SSH key permissions
Ensure all secrets are correctly set
Check Nginx and PHP-FPM logs for deployment issues

Security Recommendations

Use strong, unique passwords
Keep your system and dependencies updated
Configure firewall (UFW)
Use SSH key authentication
Limit sudo access

if you need more elaboration on any specific part of this comprehensive deployment guide, paste on the comment section.

Level Up Your AI Knowledge: Tools, Tips, and Influencers to Watch

Abdulsalam Abdulrahman (Amtech Digital) — Tue, 01 Oct 2024 23:00:00 +0000

The Rapid Pace of AI Development

The field of AI is advancing at an unprecedented pace. New tools, techniques, and applications are constantly emerging, making it a challenge to stay current. However, keeping up with these developments is crucial for anyone involved in AI. The most powerful AI model to date, GPT-4o, was released for free. GPTs are now publicly available, and video generation has evolved leaps and bounds (see Kling and VEO). Udio added features like editing lyrics after you have created a song and allowing you to use your own audio clip to make music.

Staying Informed

To stay current with the latest trends and news in AI, here are some valuable resources – some of which are technical for those who like that kind of thing:

MIT Technology Review - AI: In-depth articles and analysis on the latest AI advancements.
Towards Data Science: A platform for sharing concepts, ideas, and codes in AI and data science.
arXiv: Access to the latest research papers and technical reports in AI.

Stay Connected with Leading AI Content Creators

To stay updated with the latest trends and insights in AI, follow these influential content creators:

Matt Farmer: Shares his expertise on AI tools and marketing across various platforms.
Techfren: Offers cutting-edge coding and AI reviews and tutorials.
Brand Nat: Brings insightful AI discussions related to AI productivity.
Rajiv Shah: Provides deep dives into AI research and more fun AI content on TikTok.
Rachel Woods: Regularly discusses AI business automation.

AI for Good

As you continue your journey in the AI world, remember AI’s potential to bring about positive change and its potential for harm. Whether improving healthcare, enhancing education, or addressing environmental challenges, AI can be a powerful force for good. Be mindful of ethical considerations and strive to use AI that is inclusive, fair, and beneficial to all.

Being Community Champions

You are now equipped to be champions of AI in your communities. Share your knowledge, mentor others, and contribute to discussions about the ethical use of AI. We can create an African AI voice by fostering a community of informed and responsible AI users in Africa.

I share AI content on my LinkedIn other social media every Wednesday.

Let's use AI to make a positive impact on our world!

how to share your project as a software developer

Abdulsalam Abdulrahman (Amtech Digital) — Wed, 31 Jul 2024 10:02:33 +0000

How to share your project as a software developer

Sometimes you might what to share your software project or design to people for reviews or to encourage upcoming developers.

Below are some important steps to consider:

screen shots
project name
brief description
inspiration (add links if available)
what it does
how you built it
challenges you ran into
accomplishments that you're proud of
what you learned
what's next for the project
tech stack (what it's built with)
repo, demo or live URL links to try out
appreciation to supervisor, mentor, guidance, or team members

Below is a sample and step by step guide:

I'm using my project as a sample for you guys.

screen shots
project name
- My portfolio.
brief description
- My portfolio website contains information about me, my projects and contact form.
inspiration (add links if available)
- This project was inspired by my mentor portfolio website, Mr. Wakili Almustapha Abdullahi (https://wakili.netlify.app/)
what it does
- This project shows some of my recent projects to visitors and potential client as a proof to verify my potentials and skills.
how you built it
- The project was built with HTML, CSS and JavaScript for its functionality, it is deployed to GitHub and hosted on Netlify.
challenges you ran into.
- I face some issues hosting this project to Netlify because it was my first time doing so. As a result, I had to do some research on how to host it on Netlify, which required additional time and effort for me to complete.
accomplishments that you're proud of
- I am happy, I was able to host my portfolio website and share the URL to the public, friends and family to go through.
what you learned
- I learnt a lot from this project from being able to use Git and GitHub to hosting my portfolio online for people to see.
what's next for the project
- Adding some functionality with JavaScript and some useful content like, testimonial and downloadable resume.
tech stack (what it is built with)
- HTML, CSS, JS, GIT, GITHUB, Netlify.
repo, demo or live URL links to try out
- GitHub: https://github.com/abdulsalamamtech/
- Live URL: https://abdulsalamamtech.netlify.app/
- YouTube Demo:
appreciation to supervisor, mentor, guidance, or team members
- This project was supervised by my mentor Mr. Abdulsalam and Mr. Muhammed, I truly appreciate their support and mentorship, they are the one that motivate me to move out of my comfort zone.

What else?

You are now done with the guide on how to share your project.

Now follow and use the steps above:
Push your project to GitHub
Share your project on LinkedIn
You can also tag me @abdulsalamamtech on LinkedIn

AI for Good: Harnessing Technology for Positive Change

Abdulsalam Abdulrahman (Amtech Digital) — Wed, 24 Jul 2024 06:00:00 +0000

The AI Train is Leaving the Station (But You Can Still Catch Up!)

The world of AI is moving faster than ever before. New tools, techniques, and mind-blowing applications are popping up all the time. It can feel like you need a jetpack just to keep up! But fear not, fellow AI enthusiasts – staying informed is crucial, and luckily, it doesn't have to be a chore.

AI's Greatest Hits (So Far!)

Let's talk about some recent breakthroughs that are changing the game. The release of GPT-4, arguably the most powerful AI model to date, is a game-changer. And guess what? GPTs are now freely available for tinkerers and creators like you! Video generation has also taken a giant leap forward (check out Kling and VEO for some mind-bending examples). But wait, there's more! Udio just upped its game with features like post-creation lyric editing and the ability to use your own audio clips to make music.

Staying in the AI Know

Want to keep your finger on the pulse of AI advancements? Here are some amazing resources (don't worry, there's something for everyone, even the code enthusiasts!):

MIT Technology Review - AI: Dive deep into articles and analysis from experts on the latest AI breakthroughs.
Towards Data Science: This platform is like a playground for sharing ideas, concepts, and even code related to AI and data science.
arXiv: Get access to the latest research papers and technical reports – perfect for those who love the nitty-gritty details.

Meet Your AI BFFs

Sometimes, learning is more fun when you have a guide. Here are some amazing content creators who are passionate about sharing their AI knowledge:

Matt Farmer: This AI whiz shares his expertise on AI tools and marketing across various platforms.
Techfren: Get your coding fix with cutting-edge AI reviews and tutorials.
Brand Nat: Looking for insightful discussions on AI and productivity? Brand Nat has you covered.
Rajiv Shah: Dive deep into AI research with Rajiv, who also brings the fun factor to TikTok with engaging AI content.
Rachel Woods: Stay on top of AI's impact on business automation with Rachel's insights.

AI for Good: The Power to Change the World

As you explore the fascinating world of AI, remember its immense potential for positive change. AI can be a powerful force for good, from improving healthcare and education to tackling environmental challenges. But with great power comes great responsibility! Let's strive to use AI ethically, ensuring it's inclusive, fair, and beneficial to everyone.

Become an AI Champion in Your Community!

Now that you're armed with knowledge, it's time to share it! Mentor others, participate in discussions about responsible AI use, and spread the word. Together, we can create a strong African voice in the AI conversation, fostering a community of informed and responsible AI users across the continent.

This version uses a more conversational tone, highlights specific examples, and emphasizes the positive impact of AI. It also includes a call to action to encourage readers to get involved.

THE DIFFERENT BETWEEN LIBRARY AND FRAMEWORK AND NOT USING BOTH WITH REAL LIFE ILLUSTRATIONS

Abdulsalam Abdulrahman (Amtech Digital) — Thu, 27 Jun 2024 23:00:00 +0000

THE DIFFERENT BETWEEN LIBRARY AND FRAMEWORK
AND NOT USING BOTH WITH REAL LIFE
ILLUSTRATIONS

It's sometimes very difficult to differentiate between library and framework on this small article, we are going to explain them both with some real-life illustrations.

First, what is a library?
Libraries are basically pre-programmed modules that can be used to speed up the development process. They typically do one specific thing.

While frameworks are very similar to libraries, they are also pre-programmed, but instead of doing one specific thing, they are used to archive a lot of things at once.

A real-life illustration is about you deciding to take bread and eggs for a break.

There are many ways to get your breakfast ready; let's illustrate them.

This is an example of a framework:

You can just go and get the bread and eggs from a grocery store, fry your egg, and toss your bread, and you are ready to go, no stress; it's time-efficient and stress-free.

This is an example of using libraries:

What about if you want to make the bread on yourself?
First, you need to get flour, butter, an oven, sugar, salt, yeast, milk, and many more.
The sugar, salt, and yeasts have been processed, but you aren't doing it yourself, nor are you making your flow or oven.

But you are not yet done; how long do you think? It's going to take you to make the bread and take your breakfast?

This is an example of building from scratch:

What about if you want to make the bread and egg on your own?
First, you need to train a chicken to arch the egg, you also need to plant and process casava for the flour and make your own butter and yeast, create or manufacture your own oven, plant and process sugarcane for your sugar, process your own salt, and many more.

How stressful and time-consuming do you think this is?
How many months is it going to take? a lot, right?

This is just the difference between using a framework,
library and building from scratch, respectively.

Framework: take minimal time to archive your goals, which included a lot of different other libraries.

Making bread with all the important ingredients is a lot; this is like building from scratch.

An example of building it yourself:

is using CSS, JavaScript, or PHP on your website.

Examples of libraries:

is using Tailwind and jQuery on your website.

An example of a framework:

using Bootstrap, Angular, and Laravel on your website

I hope you get the real message from this article.

Thanks for reading through!

Understanding Libraries vs. Frameworks: Real-Life Illustrations By AbdulsalamAmtech

Abdulsalam Abdulrahman (Amtech Digital) — Mon, 24 Jun 2024 09:16:09 +0000

The difference between a library and a framework can be illustrated with real-life examples.

A library is like buying bread and eggs: pre-made components that speed up development, doing one thing well.

A framework is like getting a complete breakfast from the store: it simplifies many tasks at once.

Building from scratch is like making bread and eggs entirely by yourself: time-consuming and complex.

Libraries like jQuery and Tailwind help specific tasks, while frameworks like Laravel and Bootstrap offer comprehensive solutions.