DEV Community: Aziz Bergach

How to Make Money with the Fiverr Affiliate Program in 2025: A Comprehensive Guide

Aziz Bergach — Sat, 12 Jul 2025 22:46:10 +0000

Catchy Introduction

In the ever-evolving landscape of digital opportunities, the quest to make money online has become a driving force for many. Among the myriad avenues available, affiliate marketing stands out as a powerful and accessible model for generating passive income. Imagine earning by simply connecting people with services they already need, without having to create those services yourself. This is the core appeal of affiliate marketing, and for those looking to tap into the booming gig economy, the Fiverr affiliate program presents a particularly compelling opportunity.

Fiverr, a globally recognized marketplace for digital services, offers a unique pathway for individuals to transform their online presence into a robust online business. Through the Fiverr affiliate program, you can promote a vast array of services — from graphic design and writing to programming and video editing — and earn a commission for every successful referral. Whether you’re a seasoned marketer or just starting your journey into the world of freelancing and online entrepreneurship, this guide will walk you through everything you need to know to leverage the Fiverr affiliate program and unlock its significant earning potential in 2025.

What is the Fiverr Affiliate Program?

The Fiverr affiliate program is an initiative designed by Fiverr to reward individuals and businesses for driving new customers to its platform. Essentially, you become a partner, promoting Fiverr’s diverse range of digital services (known as ‘Gigs’) to your audience. When someone signs up and makes a purchase through your unique affiliate link, you earn a commission. It’s a win-win: new users discover valuable services, freelancers get more work, and you get paid for making the connection.

Benefits of Joining

High Earning Potential: With a wide variety of services and attractive commission rates, the potential for substantial income is considerable.
Diverse Services: Promote everything from logo design and website development to content writing and virtual assistance. This vast selection means you can always find services relevant to your niche.
Global Reach: Fiverr is a global platform, allowing you to reach an international audience and maximize your earning opportunities.
Marketing Tools & Support: Access a suite of professional marketing tools and dedicated support to help you optimize your campaigns.
Reliable Payouts: Enjoy timely and consistent payouts for your earned commissions.

Commission Plans: CPA vs. Hybrid Model

Fiverr offers different commission plans to cater to various affiliate strategies. Understanding these models is crucial for maximizing your earnings:

CPA (Cost Per Acquisition): This model pays a fixed commission for every first-time buyer you refer to Fiverr. The CPA rate can vary depending on the category of service purchased, with higher-value services often yielding larger payouts. For instance, referring a buyer who purchases a high-end web development Gig might earn you a significant flat fee.
Hybrid Model: This plan combines a smaller fixed CPA for the first-time buyer with a revenue share from their future purchases over a specific period. For example, you might get a CPA for the initial sale and then a percentage of all subsequent purchases made by that referred buyer for 12 months. This model is excellent for building passive income streams from long-term customer value.

Choosing between the CPA and hybrid model depends on your promotional strategy and target audience. If you aim for high-volume referrals of diverse services, CPA might be more straightforward. If you focus on driving users who are likely to become repeat buyers, the hybrid model could offer more sustainable long-term earnings.

How to Get Started: A Step-by-Step Guide

Embarking on your journey as a Fiverr affiliate is straightforward. Here’s a step-by-step guide to get you started:

1. Signing Up for the Program

Visit the Fiverr Affiliate Website: Navigate to the official Fiverr Affiliate Program page.
Click ‘Join Now’: You’ll be prompted to fill out a registration form with your personal details, preferred payment method, and promotional channels.
Review Terms and Conditions: Carefully read and agree to the program’s terms and conditions.
Account Activation: Once your application is reviewed and approved (usually within a few business days), you’ll receive an email confirming your account activation.

2. Understanding the Affiliate Dashboard

Upon logging in, you’ll gain access to your personalized affiliate dashboard. This is your command center for managing your campaigns. Key features include:

Performance Reports: Monitor clicks, conversions, and earnings in real-time.
Marketing Tools: Generate unique links, access banners, and other creative assets.
Payment Information: View your current earnings and payout history.
Sub-ID Tracking: Create unique identifiers for different campaigns to track their performance precisely.

3. Finding Relevant Services to Promote

The key to successful affiliate marketing is promoting services that genuinely resonate with your audience.

Niche Research: Identify your target audience’s needs and interests. What problems are they trying to solve? What services could benefit them?
Explore Fiverr Categories: Browse Fiverr’s extensive categories (e.g., Graphics & Design, Digital Marketing, Writing & Translation, Video & Animation, Programming & Tech, Business, Lifestyle).
Identify High-Demand Gigs: Look for Gigs with high ratings, numerous reviews, and competitive pricing. Consider promoting services that offer recurring value or are evergreen in demand.
Personal Experience: If you’ve used Fiverr services yourself and had a positive experience, these are often the best to promote as you can provide authentic testimonials.

Effective Strategies to Promote Fiverr Gigs and Services

Once you’re set up, the next step is to drive traffic to your affiliate links. Here are highly effective strategies:

Content Marketing

Creating valuable content is paramount for attracting and engaging your target audience.

Blog Posts: Write detailed articles reviewing specific Fiverr Gigs, comparing services, or offering tutorials.
Examples: ‘Best Logo Designers on Fiverr for Small Businesses,’ ‘How to Get a Professional Voiceover on Fiverr: A Step-by-Step Guide,’ ‘Fiverr vs. Upwork: Which Platform is Better for Freelance Writers?’
Detailed Reviews: Provide honest and thorough reviews of Fiverr services you recommend, highlighting their benefits and how they solve common problems.
Comparison Articles: Create content comparing different Gigs or freelancers within a specific niche on Fiverr, helping users make informed decisions.
Tutorials: Develop step-by-step guides on how to use a particular Fiverr service or how to order a specific Gig, embedding your affiliate links naturally.
Niche Content Ideas:
‘Top 5 AI Writing Services on Fiverr for Bloggers’
‘Getting Your Podcast Edited Professionally on Fiverr: A Full Guide’
‘Custom Website Design on Fiverr: What to Look For’

Social Media Marketing

Leverage the power of social platforms to reach a broad audience.

YouTube: Create video reviews of Fiverr Gigs, tutorials on using Fiverr services, or ‘day in the life’ videos featuring your experience with freelancers. Embed your affiliate links in the video description.
TikTok: Produce short, engaging videos showcasing quick tips, before-and-after transformations from Fiverr services, or humorous takes on common digital needs. Use relevant hashtags.
Instagram: Share visually appealing graphics promoting Fiverr services, success stories, or behind-the-scenes glimpses. Utilize Instagram Stories and Reels for quick promotions. Use the swipe-up feature (if available) or link in bio.
Facebook Groups: Participate in relevant niche-specific Facebook groups. Offer genuine advice and subtly introduce Fiverr services as solutions where appropriate, ensuring you adhere to group rules regarding promotion.

Email Marketing

Building an email list allows for direct and targeted promotions.

Lead Magnets: Offer valuable free resources (e.g., e-books, checklists, templates) in exchange for email addresses.
Targeted Promotions: Segment your email list and send tailored promotions for Fiverr Gigs that are highly relevant to each segment’s interests.
Newsletter Integration: Include recommended Fiverr services in your regular newsletters, perhaps as “tools of the week” or “services we love.”

Forum and Community Engagement

Engage in online forums and communities where your target audience spends time.

Provide Value: Answer questions, offer insights, and establish yourself as an expert.
Subtle Promotion: When relevant, gently recommend Fiverr services as solutions to common problems, always ensuring your contributions are helpful and not overtly promotional. Avoid spamming links.

SEO Optimization

Even with great content, if people can’t find it, it won’t be effective. SEO (Search Engine Optimization) is crucial.

Keyword Research: Identify the terms and phrases your target audience uses when searching for services on Fiverr. Incorporate these naturally into your content’s headings, body, and meta descriptions.
High-Quality Content: Search engines prioritize valuable, comprehensive, and well-structured content.
Backlinks: Build high-quality backlinks to your content from authoritative websites to improve your search engine ranking.
Mobile-Friendliness: Ensure your website and content are optimized for mobile devices.

Maximizing Your Earnings: Advanced Tips

To truly thrive as a Fiverr affiliate and build a sustainable online business, consider these advanced strategies:

Focusing on High-Commission Services: While promoting a wide range is good, prioritize Gigs and categories that offer higher CPA rates or are likely to result in repeat purchases under the hybrid model. For example, promoting high-value tech services or long-term business solutions can lead to greater income per conversion.
Building Trust and Authority with Your Audience: People are more likely to click on your links if they trust your recommendations. Be transparent about your affiliate relationship, provide honest reviews, and consistently deliver valuable content. Your authority in a niche will directly correlate with your conversion rates.
Analyzing Performance Data and Optimizing Campaigns: The Fiverr affiliate dashboard provides detailed analytics. Regularly review your data to understand which content and promotional channels are performing best. Identify underperforming areas and iterate on your strategies. A/B test different calls to action, headlines, and content formats.
Staying Updated with Fiverr’s New Services and Promotions: Fiverr constantly adds new Gigs and runs special promotions. Stay informed by subscribing to their affiliate newsletter and regularly checking the platform. Being an early adopter in promoting new, in-demand services can give you a significant advantage.
Diversifying Promotion Channels: Don’t put all your eggs in one basket. While you might excel in one area (e.g., blogging), exploring other channels like YouTube, podcasts, or even paid advertising can significantly expand your reach and make money online faster. Each channel caters to a different audience and content consumption preference.

Common Challenges and How to Overcome Them

While the Fiverr affiliate program offers immense potential, you might encounter some hurdles. Here’s how to address them:

Low Conversion Rates:
Solution: Re-evaluate your target audience. Are you attracting the right people? Improve the quality and relevance of your content. Ensure your calls to action are clear and compelling. Consider A/B testing different landing pages or promotional messages.
Competition:
Solution: Differentiate yourself. Focus on a specific niche where you can become an authority. Offer unique insights or a personal touch. Build a strong brand around your recommendations.
Finding the Right Audience:
Solution: Conduct thorough market research. Use social media analytics, forum discussions, and keyword research tools to understand where your target audience congregates online and what their pain points are. Tailor your content and promotions accordingly.
Algorithm Changes:
Solution: Stay agile. Search engine and social media algorithms are constantly changing. Keep up-to-date with industry news, experiment with new strategies, and diversify your traffic sources to mitigate the impact of sudden shifts.
Maintaining Originality:
Solution: Even when covering similar topics, strive to offer fresh perspectives. Share your personal experiences, conduct unique case studies, or interview Fiverr users/sellers. Focus on actionable advice and real-world scenarios that provide genuine value.

Conclusion

The Fiverr affiliate program offers an incredible pathway to make money online and build a thriving online business in 2025. By understanding its mechanics, leveraging effective promotional strategies, and continuously optimizing your efforts, you can tap into the vast potential of the gig economy. Remember, success in affiliate marketing is a journey of consistency, learning, and adaptation. Focus on providing genuine value to your audience, building trust, and diligently promoting digital services that truly solve problems.

Don’t just dream of passive income; make it a reality. Take the first step today: sign up for the Fiverr affiliate program, explore the endless possibilities of freelancing and digital services, and begin your journey towards financial independence. The digital world is brimming with opportunities — seize yours with Fiverr.

Why Investing in Cryptocurrency on Bybit in 2025 Could Be Profitable

Aziz Bergach — Thu, 21 Nov 2024 16:38:11 +0000

Why Bybit Is Your Go-To Crypto Exchange for 2025 Investments

With cryptocurrency markets gearing up for a potential bullish rally in 2025, there’s never been a better time to start investing. Analysts predict Bitcoin could soar beyond $100,000, making it a golden opportunity for those who get in early. Bybit stands out as the perfect platform for this journey, offering exclusive benefits, including a $200 reward on your first deposit when you sign up with this special referral link.

Key Reasons Bitcoin Could Hit $100,000

Institutional Investment: Institutions like BlackRock are treating Bitcoin as “digital gold,” driving demand and pushing prices higher
Bitcoin ETFs: With billions flowing into Bitcoin ETFs, this new vehicle is making crypto investments easier and more attractive to the mainstream market
Historical Trends: Bitcoin’s past performance after market highs points to strong potential for returns of 40% or more within months

Why Use Bybit?

Earn $200 Bonus: Make your first deposit on Bybit through this special link and earn up to $200 in rewards.
Low Fees: Maximize your returns with one of the lowest fee structures in the market.
Advanced Tools: Bybit provides comprehensive features for spot trading, derivatives, and portfolio management.
24/7 Support: Their customer service ensures you’re never stuck, no matter the time zone.

What Makes Bybit Special?

Bybit is more than just an exchange; it’s a gateway to financial freedom. From beginner-friendly tutorials to advanced trading tools, it empowers investors to navigate the cryptocurrency landscape confidently.

Get Started Today!

Sign up through this referral link and make your first deposit to claim your $200 bonus.
Explore Bybit’s intuitive platform and educational resources.
Invest in Bitcoin and other cryptocurrencies and capitalize on the 2025 rally.

Don’t miss out on this once-in-a-lifetime opportunity to ride the crypto wave and earn an exclusive bonus! Sign up today.

How to Create Your Own Wordle Game in HTML, CSS, and JS

Aziz Bergach — Sun, 28 Jan 2024 18:49:40 +0000

Introduction

A Glimpse into Wordle's World

Hey there! Ever caught yourself absolutely hooked on Wordle, that wildly popular word puzzle game? It's simple, fun, and oh-so-addictive, right? But what if I told you that you could channel that addiction into something incredibly productive? That's right! Today, we're diving into the exciting journey of building your very own Wordle game. And guess what? You'll be doing it with HTML, CSS, and JavaScript - the holy trinity of web development!

Why This Project Rocks for Learning

Creating a Wordle game is more than just a fun pastime. It's a hands-on way to sharpen your web development skills. You'll get to play around with the structure, design, and logic of a web application, and come out on the other side with something to show off. Ready to jump in? Let's get started!

What You'll Need: Prerequisites

The Basics: HTML, CSS, JS Knowledge

Before we start, let's make sure you've got the basics down. A comfortable grasp of HTML for structure, CSS for styling, and JavaScript for functionality is crucial. Don't worry if you're not an expert – enthusiasm and willingness to learn are your best tools here.

Free Wordle Game API access

We are going to use Wordle Game API in this tutorial as it provide a free plan to use, and I think it's really good for the purpose of the tutorial

Tools of the Trade

You'll also need a text editor (like Visual Studio Code or Sublime Text) and a browser to test your game. That's it! No fancy software required.

Setting the Stage: HTML Structure

Creating the Game Board

First things first: your HTML document. This is where you'll set up your game board. Think of it as the skeleton of your Wordle game.

Input Fields for Guesses

You'll need a place for players to input their guesses. We'll set up input fields that not only look neat but are super user-friendly.

Display Area for Feedback

Players need to know how they're doing, right? We'll create a section to display feedback for each guess. Green for right, yellow for close, and gray for try-again.

the html code structure

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Custom Wordle Game</title>
    <link rel="stylesheet" href="styles.css">
</head>
<body>
    <h1>Wordle Game</h1>
    <div id="gameBoard"></div>
    <input type="text" id="guessInput" maxlength="5">
    <button id="guessButton">Guess</button>
    <script src="script.js"></script>
</body>
</html>

Bringing It to Life: CSS Styling

Styling the Game Board

Now, let's make it pretty with CSS. We're talking colors, fonts, and layout. This is where your game starts to come alive visually.

Responsive Design Tips

We want everyone to enjoy your game, whether they're on a laptop or a smartphone. I'll show you some tricks to make your game responsive and accessible.

Color Scheme and Aesthetics

Picking the right color scheme is crucial. We'll dive into how to choose a palette that's not only appealing but also user-friendly.

The styling code in CSS*

body {
    font-family: Arial, sans-serif;
    text-align: center;
    background-color: #f0f0f0;
}

#gameBoard {
    display: grid;
  grid-template-columns: repeat(5, 1fr);
  gap: 10px;
  margin: 20px auto;
  max-width: fit-content;
}

.cell {
    width: 60px;
    height: 60px;
    border: 2px solid #333;
    text-align: center;
    line-height: 60px;
    font-size: 2em;
}

.cell.correct {
  background: #538d4e;
  color: white;
}

.cell.semi-correct {
  background: #b59f3b;
  color: white;
}

.cell.incorrect {
  background: #3a3a3c;
  color: white;
}

@media (max-width: 400px) {
  .cell {
    width: 40px;
    height: 40px;
    border: 1px solid #333;
    text-align: center;
    line-height: 40px;
    font-size: 1em;
}
}

The Game Logic: JavaScript Core

Setting Up the Game Logic

The heart of your game is its logic. We'll write JavaScript code that defines how the game works, how words are chosen, and how guesses are evaluated.

Handling User Input

We need to make sure the game responds to player input correctly. This means checking their guesses, providing hints, and keeping track of their progress.

Implementing the Wordle Algorithm

The Wordle magic lies in its algorithm. I'll guide you through creating an algorithm that randomly selects words and checks player guesses against it.

Javascript code for the wordle game

const apiKey = 'the api key from the wordle game api <X-RapidAPI-Key>'; // Replace with your API key from RapidAPI
const apiUrl = 'https://wordle-game-api1.p.rapidapi.com/guess';

const gameBoard = document.getElementById('gameBoard');
const guessInput = document.getElementById('guessInput');
const guessButton = document.getElementById('guessButton');
const inputs = [];
const results = [];

let solutionWord = '';

// Fetch a word from the API
function validate(word) {
    fetch(apiUrl, {
        "method": 'POST',
        "headers": {
          'content-type': 'application/json',
          'X-RapidAPI-Key': apiKey,
          'X-RapidAPI-Host': 'wordle-game-api1.p.rapidapi.com'
        },
        "body": JSON.stringify({word})
    })
    .then(response => response.json())
    .then(data => {
      const {result , isOk, error} = data;
      if (!isOk) {
        console.log(error)
      } else {
        inputs.push(word);
        results.push(result);
        guessInput.value = "";
        refreshGame();
      }
    })
    .catch(err => {
        console.error(err);
    });
}

// update game UI
function refreshGame() {
  const cells = gameBoard.getElementsByClassName('cell');
    for (let i = 0; i < 30; i++) { // 6 attempts, 5 letters each
        let cell = cells[i];
        let y = Math.floor(i / 5);
        let x = i - y * 5;
      if(inputs.length > y && inputs[y][x]) {
        const result = results[y][x] === "+" ? "correct" : results[y][x] === "x" ? "semi-correct" : "incorrect";
        cell.textContent = inputs[y][x].toUpperCase();
        cell.classList.add(result);
      }
    }
}

// Initialize game
function initializeGame() {
    for (let i = 0; i < 30; i++) { // 6 attempts, 5 letters each
        let cell = document.createElement('div');
        cell.classList.add('cell');
        let y = Math.floor(i / 5);
        let x = i - y * 5;
      if(inputs.length > y && inputs[y][x]) {
        const result = results[y][x] === "+" ? "correct" : results[y][x] === "x" ? "semi-correct" : "incorrect";
        cell.textContent = inputs[y][x].toUpperCase();
        cell.classList.add(result);
      }
        gameBoard.appendChild(cell);
    }
}

// Event listener for the guess button
guessButton.addEventListener('click', function() {
    let guess = guessInput.value.toLowerCase();
    if (guess.length === 5) {
        validate(guess)
    } else {
        alert('Please enter a 5-letter word.');
    }
});

initializeGame();

Enhancing User Experience

Adding Animations and Transitions

Animations can make your game feel more dynamic. We'll add some smooth transitions to make the gameplay experience even more engaging.

User Feedback and Error Handling

A great game communicates with its players. We'll implement clear messages for errors and successes, enhancing the overall user experience.

Storing Game Data

Using Local Storage for Game Progress

Don't want players to lose their progress? We'll use the browser's local storage to save their game state, so they can pick up where they left off.

Reset and Continue Game Options

Giving players the option to reset or continue their game is key. We'll add functionality for both, making your game flexible and user-friendly.

Making the Game Challenging

Implementing a Dictionary of Words

A good Wordle game needs a solid word list. We'll explore how to implement a dictionary of words that the game can use to challenge players.

Difficulty Levels and Daily Challenges

To keep things spicy, we'll add different difficulty levels and daily challenges. This will keep your players coming back for more.

Conclusion

We've covered a lot, haven't we? From setting up your HTML structure to deploying your game online, you're now ready to create your own version of Wordle. Remember, the best way to learn is by doing, so don't be afraid to experiment and make mistakes. That's how you grow!
You could check the preview here

FAQs

How do I make sure my Wordle game is unique?
Can I add more features to my game than what's covered here?
What are some common challenges I might face when coding this game?
How can I ensure my game is accessible to all players?
Where can I share my completed Wordle game to get feedback?

Next.js 14 Server Actions: Boosting Performance

Aziz Bergach — Mon, 22 Jan 2024 13:20:09 +0000

Hello developers, today I will show you how to use server actions in next js 14. For the ones who are new to next js, next js is a popular open-source framework for developing server-side rendered React applications. It was created by Vercel, the company formerly known as Zeit, and is maintained by a community of developers, like me. It aims to simplify the development process for "React js" applications by providing various features and tools that streamline the workflow and improve performance. the best thing about next js is the performance and the seo. let's get started!

What are server actions in next js

I will simplify the meaning, they are just a javascript functions, that could be define the react component or in a separated file. the only thing that let them defer from the other function is that they have "use server" in the start point of the function, like this:



// Server Component
export default function Page() {
  // Server Action
  async function create() {
    'use server'

    // ...
  }

  return (
    // ...
  )
}

they also are "async" functions, because they probably need to use "await" inside of them to call the database using prisma for example:



export default function Page() {
  // Server Action
  async function create(formData) {
    'use server'
     prisma.product.create({
     name: formData.name,
     price: formData.price
   })
  }

  return (
    <form action="create" method="POST" >
           <div>
              <label htmlFor="name">Product Name</label>
              <div>
                <input id="name" name="text" type="text"
                  placeholder="MacBook pro M2 Max"
                  required
                />
              </div>
            </div>
            <div>
              <label htmlFor="price">Product Price</label>
              <div>
                <input id="price" name="text" type="text"
                  placeholder="$15.99"
                  required
                />
              </div>
            </div>
            <div>
              <button type="submit"> Add Todo</button>
            </div>
    </form>
  )
}

Why using server actions in next js app ?

to understand that, let's talk of server side rendering "SSR".However, I will let "SSR" for another article, anyway the Server Side Rendering (SSR) is a technique used in web development to improve the user experience by rendering web pages on the server before sending them to the client's browser. So the clients or visitors of the next app would be happy, because there is no heavy tasks compiled on their browsers and it's also good for security reasons. I will cover also "client side vs server side rendering" and "client component vs server component in next js".

However, it's good to know that server actions doesn't get compiled in the browser, but in node js ">= v18" server. they are the new API endpoints in next js 14, yes as you heard they are actually end points, if you noticed in the code above, we use the server action function "create" as "action" of the "form" element in HTML:



async function create(formData) {
    'use server'
     prisma.product.create({
     name: formData.name,
     price: formData.price
   })
  }

  return (
    <form action="create" method="**POST**" >
...
</form>)

and if you have some experience using PHP programing language maybe you've noticed that what we see in the next js server actions in the same like:



<form action="script.php" method="POST">
    <label for="name">Name:</label>
    <input type="text" name="name" required>

    <label for="price">Price:</label>
    <input type="text" name="price" required>

    <button type="submit">Create Product</button>
</form>

where the "script.php" is the file where you implement the logic to insert the product to database , it may something like:



<?php

// Include your database connection logic here
// For example, assuming you have a file named "db.php" with database connection details
require_once('db.php');

if ($_SERVER["REQUEST_METHOD"] == "POST") {
    // Get form data
    $name = $_POST["name"] ?? null;
    $price = $_POST["price"] ?? null;

    // Validate form data (you may want to add more validation)
    if ($name && $price) {
        // Use MySQLi to connect to the database (adjust with your database details)
        $conn = new mysqli($db_host, $db_username, $db_password, $db_name);

        // Check the connection
        if ($conn->connect_error) {
            die("Connection failed: " . $conn->connect_error);
        }

        // Prepare and execute the SQL query to insert the product
        $stmt = $conn->prepare("INSERT INTO products (name, price) VALUES (?, ?)");
        $stmt->bind_param("ss", $name, $price);

        if ($stmt->execute()) {
            // Product inserted successfully
            echo "Product created successfully!";
        } else {
            // Handle any errors that occurred during product creation
            echo "Error creating product: " . $stmt->error;
        }

        // Close the database connection
        $stmt->close();
        $conn->close();
    } else {
        // Handle invalid form data
        echo "Invalid form data!";
    }
}
?>

next js and php use the same context for handling API calls at the same manner, like you sent a "POST" request from the "form" in php you do the same in next js 14, as you see, server actions are just API end points.

let's resume why you need use server actions in next js 14:

they get rendered in the server side
you could gather your logic in one place
you could export and use it anywhere
no more extra APIs
Fetching data from external APIs
perform business logic that requires server execution
update DB data without creating separate API routes

Implementing server actions in next js 14

After releasing next js 14, which is a wonderful update from vercel, server actions became stable and you could start using them safely right away!
In the past versions like next js 13, we implement API (server side routes) in another folder called "api" like this:



// apis
/app/api/hello/route.ts
/app/api/product/create/route.ts
/app/api/login/route.ts

// front end
/app/login/page.tsx
/app/dashboard/page.tsx

we separate the back-end from the front-end, and this could lead to creating extra endpoints or maybe an endpoint for one purpose, one page from the from end that use it.

Next js becomes more PHP like, and I think that is not bad too much. the ability of contacting with database from server or client react component is useful in many cases and make the development easy.

To use server actions in Next Js 14, you could use them directly inside the component, it doesn't matter if it is a client or server component the definition (of the server action function) and the utilize stays the same, it's like we do before. In the other hand, you could use them in separate file, the only condition is to remark the entire file with "use server" at the top so everything inside of this file will execute on the server:
/src/actions/product-actions.ts



"use server"

export async function createProduct(formData) {
     prisma.product.create({
     name: formData.name,
     price: formData.price
   })
  }

export async function updateProduct(formData) {
     prisma.product.create({
     name: formData.name,
     price: formData.price
   })
  }

How server actions work

let's jump to the work process. In a Next.js 14 app, when a user does something or met certain condition on the app, like clicking a button or filling out a form, it triggers a special async function that works on the server called "Server Action". Think of it like calling a function that works in the background.

Next.js makes the development process easy for you as a next js developer. It takes the information from the user's action, like form data like we did in the example before, then serialize the request parameters, and after that next js sends it over to the server. Once there, the server will then deserialize the request parameters, understands them, and uses the specific function related to the "Server Action" you put as action of form.
<form action="create" method="POST" >

After Server Action has finished executing successfully, the server will prepare the information, and serialize the response, and sends it back to Next.js 14, and then Next.js will deserialize the response from server and sends it to the user's browser. When everything is ready and settled, the user's browser continues doing what it needs to do on the webpage based on the received information. It's like a smooth conversation between the user's browser and the server in a Next.js application, making things work efficiently.

The utilize of server actions

in this section, we will learn what can server action do ?
Server actions are built to take rid of the API routes that you use inside the app, if your project need an external use API, meaning another app or website will use that API, then just create the /api/my-api/route.ts file.

However,the utilize of next js 14 server actions is very simple, it doesn't offer data fetching on the client, but it handles the other staff, database update and insert or fetching data from external APIs. Server actions are the new API endpint unless data fetching, use server component to do this await prisma.product.findMany(), because server component has an access to database and that wasn't weird, just read its name server component.

To utilize server actions you'll need to define them, so to define server action on server component:



// Server Component
export default function Page() {
  // Server Action
  async function create() {
    'use server'

    // ...
  }

  return (
    // ...
  )
}

and unfortunately,you can't do the same in client component, However, you could define them in separate file for example app/actions.ts, just like this:



'use server'

export async function create() {
  // ...
}

and you could the number of server actions you want, and to use them on the client component, let say app/ui/button.tsx you will need to import them and use them in a <from action="create" method="POST"> like we did in the server component:



import { create } from '@/app/actions'

export function Button() {
  return (
    // ...
  )
}

In some cases, you may need to pass this server action to a client component as prop, yes you could do it just like this <ClientComponent createProduct={create} />, and you can use it like if you import it, think of it like this:

it's a good practice if the Page for example src/app/page.tsx to be a server component and create another folder for example src/components/ui/ and put all the client components here in separate folders and then import them to your Page.
you could define a custom server action that you will just need to use in that server component (Page) and his children client components also
you can pass it throw props, or you could use context API from React Js
then start use it in the children components also

Nice, until now you've learned a lot, but we didn't finished yet :)
I still have problem, what if I create a server action that updates products (name and description) in the file src/app/actions.ts that looks like this:



'use server'

export async function update(productID, formData) {
  // ...
}

and for the component I have something like this:



'use client'

import { update } from './actions'

export function updateProduct({ productID }: { productID: string }) {

  return (
    <form action={update}>
      <input type="text" name="name" />
      <button type="submit">Update Product Name</button>
    </form>
  )
}

MMM, that's look good, but how I could get the id of the product ?
For that situation I come to you with a trick to pass the id of the product without any problem, just do like this and pass any number of args you like, but keep it like this .bind(null, arg1, arg2, ...) and you are good to go:



'use client'

import { update } from './actions'

export function updateProduct({ productID }: { productID: string }) {
  const updateProductWithId = updateProduct.bind(null, productID)

  return (
    <form action={updateProductWithId}>
      <input type="text" name="name" />
      <button type="submit">Update Product Name</button>
    </form>
  )
}

I think this method is the best, however, there is an alternative of it. Use hidden inputs like this <input type="hidden" name="productID" value={productID} /> and make sure to put them between <form> ...here... </form>, this just for anyone that doesn't like the first method for any reason :)

Different use places of server actions in next js 14

this is a too long article, but we still in progress, we didn't finished the utilize yet. maybe someone ask, is the form action the only way to use server actions in Next Js 14 ?
Good question, the simple answer is no, they can be invoked from event handlers, useEffect, third-party libraries, and other form elements like .

Invoke server actions from event handler

for example let's update a user info, using server action invoked by onClick event of a button:



import { updateUser } from './serverAction';

function UpdateUser() {
  const handleButtonClick = async () => {
    const data = { /* ... */ };
    await updateUser(data);
  };

  return (
    <button onClick={handleButtonClick}>Update User</button>
  );
}

Invoke server actions from UseEffect hook

If we say useEffect, we could imagine what may be the purpose of that server action, yes you are right, it could be two things, as I think, fetching data or tricking some thing like page view, I mean doing something when a state changed. Let's just fetch user profiles data from database using server action inside useEffect hook:



import { useEffect, useState } from 'react';
import { fetchUserProfile } from './serverActions';

function UserProfileComponent({ userId }) {
  const [userProfile, setUserProfile] = useState(null);

  useEffect(() => {
    async function getUserProfile() {
      const profile = await fetchUserProfile(userId);
      setUserProfile(profile);
    }

    getUserProfile();
  }, [userId]);

  if (!userProfile) {
    return <div>Loading profile...</div>;
  }

  return (
    <div>
      <h1>{userProfile.name}</h1>
      {/* Render other profile details */}
    </div>
  );
}

because I hate talking about something without demonstration, so here is the code to track page views with server actions and useEffect hook:



'use client'

import { incrementViews } from './actions'
import { useState, useEffect } from 'react'

export default function ViewCount({ initialViews }: { initialViews: number }) {
  const [views, setViews] = useState(initialViews)

  useEffect(() => {
    const updateViews = async () => {
      const updatedViews = await incrementViews()
      setViews(updatedViews)
    }

    updateViews()
  }, [])

  return <p>Total Views: {views}</p>
}

and if didn't understand anything, just let me know in the comment :)

Invoke server actions from third party libarary

let's take an example of 'react-query', its an npm package and you could install it by npm i react-query.



import { useQuery } from 'react-query';
import { getLatestNews } from './serverActions';

function NewsComponent() {
  const { data: news, isLoading } = useQuery('latestNews', getLatestNews);

  if (isLoading) {
    return <div>Loading news...</div>;
  }

  return (
    <div>
      {news.map((newsItem, index) => (
        <div key={index}>
          <h3>{newsItem.title}</h3>
          {/* render other news item details */}
        </div>
      ))}
    </div>
  );
}

As you see above, we’ve implemented the server action ‘getLatestNews()’ Inside of the hook ‘useQuery()’, it's quite simple.

If you have any questions, feel free to leave them in the comments section. you could find me on substack

Mastering Next.js 14: A Comprehensive Tutorial for Web Developers

Aziz Bergach — Sat, 23 Dec 2023 15:39:22 +0000

Next.js 14, the most recent iteration of the acclaimed React framework, emerges as a revolutionary advancement, aiming to refine the developer encounter and augment the efficiency of web applications. Marking a milestone, this release unveils an array of innovative features and enhancements, solidifying its status as the most substantial update in the history of Next.js.
Principally tailored for constructing server-side rendered and static web applications, Next.js 14 offers a comprehensive suite of functionalities encompassing pre-rendering, server-side rendering, static site generation, and beyond. These attributes position it as the preferred choice for developers engaged in crafting high-performance, SEO-friendly web applications.

Eloquent Example of a Simple Next.js Component

function HomePage() {

  return <div>Welcome to Next.js!</div>

}

export default HomePage

Revolutionary Advancement: Turbocharged Next.js Compiler

A pivotal enhancement in Next.js 14 lies in its turbocharged compiler. The diligent efforts of the Next.js team manifest in a Rust-based compiler that is poised to achieve stabilization imminently. The commitment to accelerating local server startup and expediting code updates underscores the significance of this development.
Empowering Developers: Forms and Mutations in Next.js 14

Introducing a streamlined approach to managing forms and mutations, Next.js 14 breaks away from the conventional method where developers were compelled to manually create API routes for handling form submissions. Enter Server Actions, empowering developers to articulate functions executed securely on the server and directly callable from React components.

async function create(formData: FormData) {

  'use server';

  const id = await createItem(formData);

}

Facilitating Developer Interaction: Server Actions Unveiled

A novel inclusion in Next.js 14, Server Actions serves to simplify the intricate process of crafting data mutations. By enabling developers to define functions executed securely on the server, directly callable from React components, this feature harmonizes with fundamental web concepts, such as forms and the FormData Web API, thus resonating with those accustomed to server-centric frameworks.

<form action={create}>

  <input type="text" name="name" />

  <button type="submit">Submit</button>

</form>

Seamless Integration: Server Actions in App Router Model

The pervasive integration of Server Actions into the App Router model augments the capabilities offered. From revalidating cached data to redirecting routes, setting and reading cookies, and handling optimistic UI updates, this comprehensive integration streamlines development workflows and elevates the overall performance of web applications.

revalidatePath('/path/to/data')

Teaser of Technological Advancement: Partial Prerendering in Next.js 14

Previewing the technological frontier, Next.js 14 unveils Partial Prerendering, an optimization within the compiler targeting dynamic content, ensuring a swift initial static response. Rooted in a decade of research spanning server-side rendering (SSR), static-site generation (SSG), and incremental static revalidation (ISR), this feature beckons a paradigm shift.

export default function Page() {

  return (

    <main>

      <header>

        <h1>My Store</h1>

        <Suspense fallback={<CartSkeleton />}>

          <ShoppingCart />

        </Suspense>

      </header>

      <Banner />

      <Suspense fallback={<ProductListSkeleton />}>

        <Recommendations />

      </Suspense>

      <NewProducts />

    </main>

  );

}

Unveiling the Vision: Motivation Behind Partial Prerendering

The rationale behind embracing Partial Prerendering lies in simplifying the existing model without burdening developers with the learning curve of new APIs. It aspires to deliver the speed and reliability of static rendering while accommodating fully dynamic, personalized responses, all without necessitating the acquisition of new knowledge.

<Suspense fallback={<ProductListSkeleton />}>

  <Recommendations />

</Suspense>

Innovation in Suspension: Partial Prerendering Anchored in React Suspense

The underpinnings of Partial Prerendering within Next.js 14 rest upon the innovative framework of React Suspense. Its mechanism involves crafting a static shell based on Suspense boundaries, with the prerendered fallback from React Suspense paving the way for dynamic components to seamlessly integrate upon request.

<Suspense fallback={<CartSkeleton />}>

  <ShoppingCart />

</Suspense>

Operational Mechanics: How Partial Prerendering Unfolds

The execution of Partial Prerendering entails an instantaneous serving of a static HTML shell upon request. Forging this shell from predefined boundaries and the prerendered React Suspense fallback, dynamic components, encompassing tasks like reading cookies or displaying personalized banners, are seamlessly streamed in tandem with the static shell. This innovative approach obviates the need for extraneous network round trips.

<main>

  <header>

    <h1>My Store</h1>

    <div class="cart-skeleton">

      <!-- Hole -->

    </div>

  </header>

  <div class="banner" />

  <div class="product-list-skeleton">

    <!-- Hole -->

  </div>

  <section class="new-products" />

</main>

Anticipating Evolution: Future Trajectory of Partial Prerendering

As a work in active progress, the evolution of Partial Prerendering unfolds with a promise of continual updates and refinements in forthcoming minor releases of Next.js. The overarching objective is to augment the developer experience and elevate the performance benchmark of web applications.

console.log('Stay tuned for more updates on Partial Prerendering');

Metadata Refinement: Unveiling Enhancements in Next.js 14

In the realm of metadata, Next.js 14 introduces pivotal refinements to enrich the user experience. By preventing flickering caused by alterations in theme color or layout shifts stemming from viewport changes, these enhancements ensure that only select metadata options block, permitting non-blocking metadata to coexist seamlessly with a partially prerendered page.

const metadata = {

  viewport: 'width=device-width, initial-scale=1',

  generateViewport: true

};

Unshackling Metadata: Decoupling Blocking and Non-Blocking Attributes

A paradigm shift in Next.js 14 is the decoupling of blocking and non-blocking metadata. The non-blocking variant ensures that alterations in metadata do not impede a partially prerendered page, mitigating flickering and layout shifts. This departure enhances the user experience by minimizing disruptions arising from metadata modifications.

const metadata = {

  nonBlocking: true

};

Emergence of Novel Options: Metadata Landscape in Next.js 14

The introduction of novel metadata options in Next.js 14 prompts a transition from deprecated choices. Notably, viewport and generateViewport emerge as new additions, while existing metadata options remain intact. Developers are encouraged to embrace these contemporary APIs, with legacy options continuing to function until their eventual removal in a future major version.

const metadata = {

  viewport: 'width=device-width, initial-scale=1'

};

Culmination: Next.js 14 Unveils a Technological Panorama

In summation, the advent of Next.js 14 heralds a plethora of features and refinements that redefine the developer landscape and amplify the performance trajectory of web applications. From the prowess of Server Actions to the foresight of Partial Prerendering and the nuanced handling of metadata, Next.js 14 stands as an indispensable asset for front-end web developers.

DEV Community: Aziz Bergach

How to Make Money with the Fiverr Affiliate Program in 2025: A Comprehensive Guide

Catchy Introduction

What is the Fiverr Affiliate Program?

Benefits of Joining

Commission Plans: CPA vs. Hybrid Model

How to Get Started: A Step-by-Step Guide

1. Signing Up for the Program

2. Understanding the Affiliate Dashboard

3. Finding Relevant Services to Promote

Effective Strategies to Promote Fiverr Gigs and Services

Content Marketing

Social Media Marketing

Email Marketing

Forum and Community Engagement

SEO Optimization

Maximizing Your Earnings: Advanced Tips

Common Challenges and How to Overcome Them

Conclusion

Why Investing in Cryptocurrency on Bybit in 2025 Could Be Profitable

Why Bybit Is Your Go-To Crypto Exchange for 2025 Investments

Key Reasons Bitcoin Could Hit $100,000

What Makes Bybit Special?

Get Started Today!

How to Create Your Own Wordle Game in HTML, CSS, and JS

Introduction

A Glimpse into Wordle's World

Why This Project Rocks for Learning

What You'll Need: Prerequisites

The Basics: HTML, CSS, JS Knowledge

Free Wordle Game API access

Tools of the Trade

Setting the Stage: HTML Structure

Creating the Game Board

Input Fields for Guesses

Display Area for Feedback

the html code structure

Bringing It to Life: CSS Styling

Styling the Game Board

Responsive Design Tips

Color Scheme and Aesthetics

The styling code in CSS*

The Game Logic: JavaScript Core

Setting Up the Game Logic

Handling User Input

Implementing the Wordle Algorithm

** Javascript code for the wordle game**

Enhancing User Experience

Adding Animations and Transitions

User Feedback and Error Handling

Storing Game Data

Using Local Storage for Game Progress

Reset and Continue Game Options

Making the Game Challenging

Implementing a Dictionary of Words

Difficulty Levels and Daily Challenges

Conclusion

FAQs

Next.js 14 Server Actions: Boosting Performance

What are server actions in next js

Why using server actions in next js app ?

Implementing server actions in next js 14

How server actions work

The utilize of server actions

Different use places of server actions in next js 14

Invoke server actions from event handler

Invoke server actions from UseEffect hook

Invoke server actions from third party libarary

Mastering Next.js 14: A Comprehensive Tutorial for Web Developers

Eloquent Example of a Simple Next.js Component

Revolutionary Advancement: Turbocharged Next.js Compiler

Facilitating Developer Interaction: Server Actions Unveiled

Seamless Integration: Server Actions in App Router Model

Teaser of Technological Advancement: Partial Prerendering in Next.js 14

Unveiling the Vision: Motivation Behind Partial Prerendering

Innovation in Suspension: Partial Prerendering Anchored in React Suspense

Operational Mechanics: How Partial Prerendering Unfolds

Anticipating Evolution: Future Trajectory of Partial Prerendering

Metadata Refinement: Unveiling Enhancements in Next.js 14

Unshackling Metadata: Decoupling Blocking and Non-Blocking Attributes

Javascript code for the wordle game