Before we learn about the money, let’s get this question out of the way:

What Is Terraform?

Let’s have a look at the definition from the official Terraform website:

“Terraform is an open-source infrastructure as code software tool that provides a consistent CLI workflow to manage hundreds of cloud services. Terraform codifies cloud APIs into declarative configuration files.”

Now that you know about what it is, let’s have a look at what it earns next!

Annual Income

How much does a Terraform Developer make per year?

The average annual income of a Terraform Developer in the United States is $116,000 per year according to PayScale (source). Top earners make $185,000 and more in the US!

Here’s a table with salary levels of jobs using the Terraform skillset to create more value for their companies and organizations:

Let’s have a look at the hourly rate of Terraform Developers next!

Hourly Rate

Terraform Developers are well-paid on freelancing platforms such as Upwork or Fiverr.

• Related Article: What’s the best freelancing platform?

If you decide to go the route as a freelance Terraform Developer, you can expect to make between $40 and $200 per hour on Upwork (source). Assuming an annual workload of 2000 hours, you can expect to make between $80,000 and $400,000 per year.

Note: Do you want to create your own thriving coding business online? Feel free to check out our freelance developer course — the world’s #1 best-selling freelance developer course that specifically shows you how to succeed on Upwork and Fiverr!

Industry Demand

But is there enough demand? Let’s have a look at Google trends to find out how interest evolves over time (source):

Work Description

So, you may wonder: Terraform Developer – what’s the definition?

Terraform Developer Definition: A Terraform Developer is a DevOps engineer who manages a possibly large number of cloud platforms — such as AWS, Azure, or Google Cloud — via remote access and the Terraform utility toolsets.

Learning Path, Skills, and Education Requirements

Do you want to become a Terraform Developer? Here’s a step-by-step learning path I’d propose to get started with Terraform:

• Step 1: Introduction to Computer Science (~40 hours)
• Step 2: Introduction to AWS (~20 hours)
• Step 3: Introduction to Azure (~20 hours)
• Step 4: Introduction to Google Cloud (~20 hours)
• Step 5: Introduction to Kubernetes (~20 hours)
• Step 6: Introduction to Terraform (~20 hours)
• Step 7: Introduction to Terraform (Free Video Courses) (~10 hours)

You can find many additional computer science courses on the Finxter Computer Science Academy (flatrate model).

But don’t wait too long to acquire practical experience!

Even if you have little skills, it’s best to get started as a freelance developer and learn as you work on real projects for clients — earning income as you learn and gaining motivation through real-world feedback.

Tip: An excellent start to turbo-charge your freelancing career (earning more in less time) is our Finxter Freelancer Course. The goal of the course is to pay for itself!

Related Video

You can find more job descriptions for coders, programmers, and computer scientists in our detailed overview guide:

• Get Your Job in IT [Overview]

Related Income of Professional Developers

The following statistic shows the self-reported income from 9,649 US-based professional developers (source).

The average annual income of professional developers in the US is between $70,000 and $177,500 for various programming languages.

Question: What is your current total compensation (salary, bonuses, and perks, before taxes and deductions)? Please enter a whole number in the box below, without any punctuation. If you are paid hourly, please estimate an equivalent weekly, monthly, or yearly salary. (source)

The following statistic compares the self-reported income from 46,693 professional programmers as conducted by StackOverflow.

The average annual income of professional developers worldwide (US and non-US) is between $33,000 and $95,000 for various programming languages.

Here’s a screenshot of a more detailed overview of each programming language considered in the report:

Here’s what different database professionals earn:

Here’s an overview of different cloud solutions experts:

Here’s what professionals in web frameworks earn:

There are many other interesting frameworks—that pay well!

Look at those tools:

Okay, but what do you need to do to get there? What are the skill requirements and qualifications to make you become a professional developer in the area you desire?

Let’s find out next!

General Qualifications of Professionals

StackOverflow performs an annual survey asking professionals, coders, developers, researchers, and engineers various questions about their background and job satisfaction on their website.

Interestingly, when aggregating the data of the developers’ educational background, a good three quarters have an academic background.

Here’s the question asked by StackOverflow (source):

Which of the following best describes the highest level of formal education that you’ve completed?

However, if you don’t have a formal degree, don’t fear! Many of the respondents with degrees don’t have a degree in their field—so it may not be of much value for their coding careers anyways.

Also, about one out of four don’t have a formal degree and still succeeds in their field! You certainly don’t need a degree if you’re committed to your own success!

Freelancing vs Employment Status

The percentage of freelance developers increases steadily. The fraction of freelance developers has already reached 11.21%!

This indicates that more and more work will be done in a more flexible work environment—and fewer and fewer companies and clients want to hire inflexible talent.

Here are the stats from the StackOverflow developer survey (source):

Do you want to become a professional freelance developer and earn some money on the side or as your primary source of income?

Resource: Check out our freelance developer course—it’s the best freelance developer course in the world with the highest student success rate in the industry!

Other Programming Languages Used by Professional Developers

The StackOverflow developer survey collected 58000 responses about the following question (source):

Which programming, scripting, and markup languages have you done extensive development work in over the past year, and which do you want to work in over the next year?

These are the languages you want to focus on when starting out as a coder:

And don’t worry—if you feel stuck or struggle with a nasty bug. We all go through it. Here’s what SO survey respondents and professional developers do when they’re stuck:

What do you do when you get stuck on a problem? Select all that apply. (source)

Related Tutorials

To get started with some of the fundamentals and industry concepts, feel free to check out these articles:

• Freelance Developer – How to Code From Home and Earn Six Figures [Industry Report]
• How to Become a Python Freelancer—and Earn $1,000 on the Side? [A Step-by-Step Tutorial]
• How Adam Earns $5000 per Month as a Python Freelancer on Upwork [Month 4]
• Terraform Wikipedia
• Learn Terraform Google

Where to Go From Here?

Enough theory. Let’s get some practice!

Coders get paid six figures and more because they can solve problems more effectively using machine intelligence and automation.

To become more successful in coding, solve more real problems for real people. That’s how you polish the skills you really need in practice. After all, what’s the use of learning theory that nobody ever needs?

You build high-value coding skills by working on practical coding projects!

Do you want to stop learning with toy projects and focus on practical code projects that earn you money and solve real problems for people?

If your answer is YES!, consider becoming a Python freelance developer! It’s the best way of approaching the task of improving your Python skills—even if you are a complete beginner.

If you just want to learn about the freelancing opportunity, feel free to watch my free webinar “How to Build Your High-Income Skill Python” and learn how I grew my coding business online and how you can, too—from the comfort of your own home.

Join the free webinar now!

If you are considering investing time in learning about blockchain, it can seem a weighty undertaking.  There are a multitude of blockchain variants such as Bitcoin, Ethereum, Litecoin, and Dogecoin, and the terminology can be just as confusing. 

Four general types of blockchain networks are in use today: public, private, consortium, and permissioned.  Each has its own rules as to who may administer the blockchains and who can participate as a node.

Of the blockchain variants, Ethereum is appealing due to its community-driven nature, and it allows for many use cases including DeFi (decentralized finance), DApps (decentralized applications), and NFTs (non-fungible tokens). 

To begin working with Ethereum, I started looking for tutorials, and there are certainly a lot of them.  I visited several sites that turned up in my searches.  I began at ethereum.org, where it bills itself as the programmable blockchain.

The learning section on the Ethereum website contains well over 150 tutorials, and Solidity has over 40 entries. 

Info: Solidity is a high-level, object-oriented language for creating smart contracts (smart contracts are essentially the code or programs stored in the blockchain when sent from a wallet, whereupon the code executes), and is similar in appearance to Python or JavaScript. 

In no particular order, the following tutorials are among the most notable I found during my search.

Solidity for Beginners: Smart Contract Development Crash Course

Gregory McCubbin’s tutorial at Dapp University is a short tutorial for beginners, covering the basics of creating smart contracts.  It doesn’t linger on terminology and history but starts Solidity coding examples right away in the Remix IDE. 

So if you are eager to see Solidity in use, this quick tutorial (about an hour and a half) gets straight to the point.

Topics covered are language-related, such as constructors, data types, internal functions, etc.  This is a good tutorial for following along in an editor. 

I tried taking notes on paper, but decided better of it and resorted to my laptop.  The examples are easy to understand if you are already familiar with programming concepts, and the videos are short, about 15 – 20 minutes each. 

If you just want to get exposure to Solidity, you may find it worth the time, just don’t expect to use the code immediately. 

The examples in this tutorial are meant for explaining a few of the intricacies of Solidity, and is a small investment of your time to see what Solidity looks like with a few use cases.

Solidity Tutorial: How to Create NFTs with Hardhat

Learn how to leverage Node.js to build Ethereum Dapps and smart contracts.  If you are a JavaScript programmer, this tutorial steps you through the process of installing and configuring a Hardhat development environment with npm, the Node Package Manager.

This is a straightforward, text-based tutorial. 

There is little Solidity code, but the point is to avail yourself of the tools needed to write Solidity in a local, console-based, JavaScript IDE. 

You step through installing the environment, setting up a project, compiling a Solidity contract, and deploying it on the local network.  While you will need more knowledge of the Solidity language to write contracts and Dapps, this tutorial will help you set up your framework.

Solidity Smart Contract Tutuorials

Another text-based tutorial is at w3schools.io. 

It is more akin to documentation and use cases.  It doesn’t appear to be up to date, and uses varying Solidity versions. 

While there is no actual contract or Dapp built, the tutorial covers almost all of the features and keywords of the Solidity language. 

For instance, source code comments can be inline or block format like C++, and currency units are Wei, Finney, szabo, and ether.  I only listed this one for its brevity and still relevant information.

Hello World Smart Contract

Most beginners would probably want to check out this tutorial hosted at Ethereum.org. 

It is a full-stack guide using JavaScript and Solidity to build a Dapp. 

The only criticism is the need to create multiple 3^rd party accounts, such as an Alchemy account for access to Web3 APIs and to generate an API key. 

Hardhat is used as a console-based IDE, and online services Ropsten Etherscan and Metamask are used for blockchain testing and access to a crypto wallet, respectively.  It is the most complete text-based tutorial I’ve read so far.

Complete Guide On Solidity Programming

Part of a larger Blockchain tutorial for beginners, this tutorial steps through Solidity programming from the basics of pragma directives and data types to Smart Contract design patterns. 

There are both textual and video components to this tutorial. 

I found the video tutorial more instructive, while the textual content was good as a guide or outline.

If you learn by jumping in immediately, I suggest focusing on the video portion of this tutorial. In fact, if the thoroughness of this tutorial is any indication, the whole Blockchain playlist of 26 tutorials would be a very good starting point. It covers Etherium, Bitcoin, Dogecoin, Dapps, Merkle Tree, NFT vs. Crypto, and a lot more.  It is current and last updated Feb 16, 2022.

Learn Solidity: Absolute Beginners Solidity Tutorial

From Tutorialspoint comes this tutorial for novices. 

The course assumes prior knowledge of programming in general and some basic familiarity with blockchain. 

It is a little dated, but it covers everything about Solidity. 

Navigation is as easy as clicking a heading on the sidebar.

I was impressed with the amount of content, and this would make an excellent reference page for Solidity. It was like reading the C/C++ reference documentation.  This is a text-only tutorial, and its primary mode of delivery is by example. 

Once you start writing smart contracts in Solidity, this tutorial could be handy to refer back to.

Solidity Tutorial: A Detailed Introduction

This is the tutorial I would suggest starting with. 

It is a year old, but there isn’t much code involved.  It is a good introduction to Solidity and Ethereum in general.  Compiler installation is covered, as well as Remix IDE and Docker images.  A quick introduction to syntax is followed by types, variables, and a few use cases.

Coverage of Ethereum, EVM, and smart contracts is seldom included in the tutorials I’ve reviewed.  The author delivers these details to help define what will be covered in this Solidity tutorial, a method called pre-learning in educational sciences.

Smart Contract Tutorial: Create a lottery smart contract in Solidity

Block Explorer put out a series of videos on smart contracts on YouTube.  The content is focused on smart contracts, but ventures into Web3.js, Chainlink, and Solidity among other topics. 

This particular video covers some peculiarities in Solidity as a lottery smart contract is built.  Remix IDE on the Ethereum site is used to sandbox the contract, so you can test functionality while refinements are made.  This video succeeds in giving a good overview of Solidity basics in about 45 minutes.

Web3 Tutorial: Solidity Smart Contracts

The penultimate tutorial I considered for this article is from Part Time Larry, and is the third of a series of ten recent tutorials on smart contracts.  The tutorial is organized as a series of posts at hackingthemarkets.com. 

The posts each relate to a topic in current Web3 practices regarding smart contracts.

This particular post has the viewer follow along, writing a smart contract within a full-stack environment that is already in place.  It’s a very thorough video with a textual component.  Seeing the tools used helps the viewer become familiar with them as they move back and forth between editor and console.

Solidity Blockchain Smart Contracts: Beginner to Expert

This final tutorial comes from one of my favorite tutorial websites, freecodecamp.org.  I think their work creating free tutorials to help people learn to code is exceptional. 

This tutorial is exceptional as well, it’s sixteen hours of coursework packed into one video.  I am still going through various parts, rewinding and reviewing areas I need to brush up on. 

I will be using this course for a few months I’m sure.

Almost everything in all the other videos is covered here with some additional content.  In addition to that, Python is used in this course, so it is relevant to my current endeavors as a Python developer. 

This tutorial/course should be considered if the previous tutorials were interesting and you are thinking about working in this niche as a developer.

Conclusion

I hope these tutorials are useful, and shed some light on what Solidity is used for. 

Most simply touch on what Solidity and smart contracts are, but a few of them are full courses. 

Whatever the level of interest you have in blockchain and Ethereum, with the investment of a little time, you are sure to find something of note in them.

---

Learn Solidity Course

Solidity is the programming language of the future.

It gives you the rare and sought-after superpower to program against the “Internet Computer”, i.e., against decentralized Blockchains such as Ethereum, Binance Smart Chain, Ethereum Classic, Tron, and Avalanche – to mention just a few Blockchain infrastructures that support Solidity.

In particular, Solidity allows you to create smart contracts, i.e., pieces of code that automatically execute on specific conditions in a completely decentralized environment. For example, smart contracts empower you to create your own decentralized autonomous organizations (DAOs) that run on Blockchains without being subject to centralized control.

NFTs, DeFi, DAOs, and Blockchain-based games are all based on smart contracts.

This course is a simple, low-friction introduction to creating your first smart contract using the Remix IDE on the Ethereum testnet – without fluff, significant upfront costs to purchase ETH, or unnecessary complexity.

Fetching and displaying a bulk of records on a single fetch is not a good practice. It will increase the server load and has more disadvantages.

Pagination will resolve this problem.

Most of the website shows links of numbers for pagination. There are different ways to add pagination. Some of them are listed below.

1. Previous-next navigation controls.
2. Number links 1, 2, 3 … up to … total number of pages.
3. A restricted number of page links that are expandable on navigation.

In this tutorial, we are going to see an example of a PHP pagination code with search sorting.

This example adds pagination to a list of records displayed in a tabular view. It uses jQuery AJAX to fetch records for each page from the database.

What is pagination

• The Pagination is a simple method to split voluminous data into pages. It prevents the disadvantages of displaying all records on a page.
• It shows a limited number of records per page which lets a quick glance at the page result.
• Paginated results require the start offset and per-page count to set the LIMIT to fetch.

Merits and demerits of pagination

There are more merits of using PHP pagination. Some of them are listed below.

• It increases efficiency by loading the page content quickly.
• It reduces server overload.
• The pagination links will reveal the approximate data stuff of the application.
• It will greatly improve site responses on displaying the media library with pagination.
• It increases user experience in browsing the paginated results.

Almost PHP pagination has no demerits, but it is not suitable in some scenarios. For example,

• It is skippable for applications displaying records that are countable by fingers.
• Without relational attributes (like prev, next URL), it gives negative impacts on SEO’s point of view.

About this example

This example has the code to group the pagination, sorting, search for a listing page.

The pagination UI will show limited pagination links. It extends the link stack on moving forward page by page.

In this example, we have three options based on which pagination format will be changed.

The pagination request carries over the search and sorting parameters if exist.

It calls an AJAX script to send the pagination, search and sort request data to the PHP.

It allows to search and sort by name via AJAX. The default sorting order is ascending (ASC) to sort the name column in alphabetical order.

The on-click event of the column header switches the sorting orders between ‘ASC’ and ‘DESC’

File structure

This is the file structure of the PHP pagination example. The has the paginated results to be rendered into the home page.

The list.php is to display the results queried with a per-page limit. The perpage.php file contains the handlers to prepare the pagination HTML to be shown into the UI.

Home page HTML to render pagination UI

The following code shows the HTML to display the member database results.

It displays a name-wise search panel above the table header. Also, the first column displays the member names with a sorting feature.

The PHP pagination, search and sorting actions give results without page refresh. It uses jQuery AJAX to request PHP to perform these actions without reloading the page.

The “listViaAJAX()” JavaScript function request PHP pagination result via AJAX. The “sortList()” function, sets the ordering request parameters to get the sorted results.

The search form submit-button invokes the listViaAJAX() code to send the keyword. In the callback, it gets the response HTML from the server and updates the UI.

index.php

<html>

<head> <link href="./assets/style.css" type="text/css" rel="stylesheet" />

</head>

<body> <h2 class="page-title">PHP Pagination with Search</h2> <div id="grid"> <form name="frmSearch" id="frmSearch" method="post" action="index.php"> <div class="search-box"> <label>Search :</label> <input type="text" id="search" placeholder="name" name="filter_value" class="demoInputBox" /> <input type="button" name="go" class="search-form-btn" value="Search" on‌Click="listViaAJAX();"> <input type="reset" class="search-form-btn" value="Reset" on‌click="window.location='index.php'"> </div> <table id=mytable cellpadding="10" cellspacing="1"> <thead> <tr> <th class="sortable"><span on‌Click="sortList();"><input type="hidden" name="order_type" id="order-type" value="asc" />Name</span> <img src='images/sort-down.svg' /></th> <th>Registered Date</th> <th class="align-right">Subscription Amount</th> </tr> </thead> <tbody id="table-body"> <?php require_once __DIR__ . '/list.php'; ?> <tbody> </table> </form> </div>

</body>

<script src="https://code.jquery.com/jquery-3.6.0.min.js" integrity="sha256-/xUj+3OJU5yExlq6GSYGSHk7tPXikynS7ogEvDej/m4=" crossorigin="anonymous"></script>

<script src='./assets/pagination-ajax.js'></script>

</html> 

Paginated database results in a tabular view

This list.php file is to fetch and output the results to the UI. This PHP pagination request is called via AJAX by clicking the page links.

The below code prepares the MySQL query to fetch the data from the database. This query uses LIMIT to display the data with the per-page limit.

This code gets the total records’ count and per-page limit. It passes these two parameters the showPerpage() function to generate the PHP pagination HTML.

Added to the pagination parameters, this PHP code receives the search, sort request.

It prepares the WHERE and ORDER BY clause based on the search and sort request. These clauses are attached to the query to get the filtered result.

list.php

<?php

use Phppot\DataSource; require_once "perpage.php";

require_once __DIR__ . "/lib/DataSource.php";

$dataSource = new DataSource(); $name = "";

$queryCondition = "";

$paramType = "";

$paramValue = array();

if (! empty($_POST["filter_value"])) { $name = $_POST["filter_value"]; $queryCondition .= " WHERE name LIKE ?"; $paramType .= 's'; $paramValue[] = $_POST["filter_value"] . '%';

} $orderBy = "name";

$order = "asc";

if (! empty($_POST["order_type"])) { $order = $_POST["order_type"];

} $nextOrder = "asc";

if ($order == "asc") { $nextOrder = "desc";

}

$query = "SELECT * from tbl_member " . $queryCondition . " ORDER BY " . $orderBy . " " . $order . " ";

$href = 'index.php';

$perPage = 5;

$page = 1;

if (isset($_POST['pagination_offset'])) { $page = $_POST['pagination_offset'];

}

$start = ($page - 1) * $perPage; if ($start < 0) $start = 0; $queryWithLimit = $query . " limit " . $start . "," . $perPage; $resultpage = $dataSource->select($queryWithLimit, $paramType, $paramValue); if (! empty($resultpage)) { $count = $dataSource->getRecordCount($query, $paramType, $paramValue); $resultpage["perpage"] = showperpage($count, $perPage, $href);

}

?>

<?php if (! empty($resultpage)) { foreach ($resultpage as $k => $v) { if (is_numeric($k)) { ?> <?php $date = $resultpage[$k]["date"]; $newDate = date("d-m-Y", strtotime($date)); ?>

<tr> <td class="column1"><?php echo $resultpage[$k]["name"]; ?></td> <td class="column2"><?php echo $newDate ?></td> <td class="column3 align-right">$ <?php echo $resultpage[$k]["subscription_amount"]; ?></td>

</tr>

<?php } }

}

if (isset($resultpage["perpage"])) { ?>

<tr> <td colspan="5" class="align-center"> <?php echo $resultpage["perpage"]; ?></td>

</tr>

<?php } ?> 

External handlers to prepare PHP pagination controls

It uses a constant to split the database results into pages. This code uses the following two functions.

• perpage() – prepares the HTML for the pagination UI links.
• showperpage() – returns pagination HTML response.

The perpage() function adds the onClick attribute to the PHP pagination links. It calls the AJAX code by sending the pagination query offset.

It uses the offset, per-page count and the total number of records to calculate the number of pages.  It runs a loop through the number of pages to display the pagination links.

It adds HTML attributes to highlight the current page among the page links.

perpage.php

<?php

function perpage($count, $per_page = '5',$href) { $output = ''; $paging_id = "link_perpage_box"; if(!isset($_POST["pagination_offset"])) $_POST["pagination_offset"] = 1; if($per_page != 0) $pages = ceil($count/$per_page); if($pages>1) { if(($_POST["pagination_offset"]-3)>0) { if($_POST["pagination_offset"] == 1) $output = $output . '<span id=1 class="current-page">1</span>'; else $output = $output . '<input type="hidden" name="pagination_offset" value="1" /><input type="button" class="perpage-link" value="1" on‌Click="listViaAJAX()" />'; } if(($_POST["pagination_offset"]-3)>1) { $output = $output . '...'; } for($i=($_POST["pagination_offset"]-2); $i<=($_POST["pagination_offset"]+2); $i++) { if($i<1) continue; if($i>$pages) break; if($_POST["pagination_offset"] == $i) $output = $output . '<span id='.$i.' class="current-page" >'.$i.'</span>'; else $output = $output . '<input type="hidden" name="pagination_offset" value="' . $i . '" /><input type="button" class="perpage-link" value="' . $i . '" on‌Click="listViaAJAX()" />'; } if(($pages-($_POST["pagination_offset"]+2))>1) { $output = $output . '...'; } if(($pages-($_POST["pagination_offset"]+2))>0) { if($_POST["pagination_offset"] == $pages) $output = $output . '<span id=' . ($pages) .' class="current-page">' . ($pages) .'</span>'; else $output = $output . '<input type="hidden" name="pagination_offset" value="' . $pages . '" /><input type="button" class="perpage-link" value="' . $pages . '" on‌Click="listViaAJAX()" />'; } } return $output;

} function showperpage($count, $per_page = 5, $href)

{ $perpage = perpage($count, $per_page,$href); return $perpage;

}

?> 

jQuery AJAX script to call paginated list from PHP

This jQuery AJAX script calls the PHP pagination code on the server-side.

It calls the PHP endpoint index.php by sending the form data. It serializes and posts the following data to the PHP.

• Page offset. Default is 0.
• Search keyword.
• Sorting order. Default is ascending order(ASC).

The sortlist() function toggles the sorting order by clicking the corresponding column name.

pagination-ajax.js

function listViaAJAX() { $.ajax({ method: "POST", url: "list.php", data: $("#frmSearch").serialize(), }).done(function( response ) { $("#table-body").html(response); });

} function sortList() { if($("#order-type").val() == 'asc') { $("#order-type").val('desc'); $(".sortable img").attr("src", "images/sort-up.svg"); } else { $("#order-type").val('asc'); $(".sortable img").attr("src", "images/sort-down.svg"); } listViaAJAX();

} 

Database script

Download the below database script into your environment. It shows the database schema with the table structure.

It also has the sample data in the target database table. It supports to start seeing the PHP pagination code result with search.

sql/database.sql

 --

-- Database: `blog_eg`

-- -- -------------------------------------------------------- --

-- Table structure for table `tbl_member`

-- CREATE TABLE `tbl_member` ( `id` int(255) NOT NULL, `name` varchar(256) NOT NULL, `date` date NOT NULL, `subscription_amount` varchar(256) NOT NULL

) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4; --

-- Dumping data for table `tbl_member`

-- INSERT INTO `tbl_member` (`id`, `name`, `date`, `subscription_amount`) VALUES

(1, 'Jennifer d\' Sousa ', '2022-01-20', '10'),

(2, 'Tom Adomian', '2021-12-25', '10'),

(3, 'Vincent Thomas', '2021-12-24', '100'),

(4, 'Lara Ricky', '2021-12-25', '100'),

(5, 'Kevin Fernandes', '2021-12-17', '100'),

(6, 'Leena Christy', '2021-12-16', '40'),

(7, 'Christian Benchamin', '2021-12-19', '60'),

(8, 'Abraham Maslow', '2021-12-17', '175'),

(9, 'Helan Immaculate', '2021-12-16', '190'),

(10, 'Jane Jancy', '2021-12-19', '30'); --

-- Indexes for dumped tables

-- --

-- Indexes for table `tbl_member`

--

ALTER TABLE `tbl_member` ADD PRIMARY KEY (`id`); --

-- AUTO_INCREMENT for dumped tables

-- --

-- AUTO_INCREMENT for table `tbl_member`

--

ALTER TABLE `tbl_member` MODIFY `id` int(255) NOT NULL AUTO_INCREMENT, AUTO_INCREMENT=24; 

PHP pagination output

The following screenshot displays the PHP pagination code. It shows the tabular results with pagination links and a search panel.

Download

↑ Back to Top