One place for hosting & domains

      Pages

      How To Generate Pages from Markdown in Gatsby


      The author selected the Internet Archive to receive a donation as part of the Write for DOnations program.

      Introduction

      One of the key features of the popular static site generator Gatsby is its flexibility in consuming content sources. Gatsby can generate static pages from almost any data source, such as a Content Management System (CMS), API, database, or even a local file system.

      Markdown files are a popular file-based source to use with Gatsby. Markdown is a markup language that is lightweight and designed for readability, which makes it ideal for documentation projects, blog posts, or any text-heavy websites.

      In this tutorial, you will create a Gatsby-powered static site that builds itself from local Markdown source files, using the gatsby-source-filesystem plugin to collect the files and the gatsby-transformer-remark plugin to convert them into HTML.

      Prerequisites

      Before starting, here are a few things you will need:

      • A local installation of Node.js for running Gatsby and building your site. The installation procedure varies by operating system, but DigitalOcean has guides for Ubuntu 20.04 and macOS, and you can always find the latest release on the official Node.js download page.
      • Some familiarity with JavaScript, for working in Gatsby. The JavaScript language is an expansive topic, but a good starting spot is our How to Code in JavaScript series.
      • Some familiarity with React and JSX, as well as HTML elements, if you want to customize the user interface (UI) of your posts beyond what is covered in this tutorial.
      • A new Gatsby project named markdown-tutorial, scaffolded from gatsby-starter-default. To build a new Gatsby project from scratch, you can refer to Step 1 of the How To Set Up Your First Gatsby Website tutorial.

      This tutorial was tested on Node.js v14.16.1, npm v6.14.12, Gatsby v3.10.2, gatsby-source-filesystem v3.10.0, and gatsby-transformer-remark v4.7.0.

      Step 1 — Standardizing Your Markdown Content

      Given Markdown’s flexibility as a markup language, documents written in Markdown can take on various forms and levels of complexity. Gatsby does not require you to format all your Markdown files in the same way, but to make your site and URLs easier to organize, you will first standardize how you write and store your Markdown files within this project.

      For this tutorial, you will add blog posts to your site, and each post will have a title, customized URL, publication date, and post body. You will start with a single post, Learning About Gatsby, where you can share your experience of learning about Gatsby with the world.

      In preparation for storing this and future posts, create a new directory under src, named blog. If you prefer to do this from the command line, you can do so with mkdir from the root directory of the project:

      Next, create an empty Markdown file within that new directory. For the purposes of this tutorial, filenames do not control the published URL or SEO, so the naming conventions here are just to keep things organized. Give your new post a filename of learning-about-gatsby.md.

      You can either do this in your IDE, or use the terminal with touch:

      • touch src/blog/learning-about-gatsby.md

      Finally, fill in the actual content of the post. Open the file in your editor of choice and add the following:

      markdown-tutorial/src/blog/learning-about-gatsby.md

      ---
      title: "Learning about Gatsby"
      slug: "/blog/learning-about-gatsby"
      date: "2021-08-01"
      ---
      
      ## What I'm Working On
      
      Right now, I'm working through a [DigitalOcean tutorial](https://www.digitalocean.com/community/tutorials) on using [Gatsby](https://www.gatsbyjs.com/) with Markdown.
      

      The top section enclosed by --- is called frontmatter and consists of key-value pairs. It is written in YAML, which is a configuration language outside of Markdown. Property keys go on the left, and your values go on the right. In your frontmatter block, you have defined values for your post’s title, the publication date, and the slug. The slug is the customized portion of the post’s URL that comes after your domain name (also known as the path).

      Any text below the frontmatter will become the post body. Within that area, you have a heading of What I'm Working On, with two hash symbols (##) at the beginning of the line. In Markdown, this indicates a level-2 heading, which Gatsby will convert into <h2></h2> in HTML. Within the text below that heading, you have some links that are written using Markdown syntax: [link_text](link_destination).

      Save your changes to learning-about-gatsby.md and then close the file.

      You have just created your first post using Markdown and saved it within your project’s source code. You have also standardized the format, including specific property values in the frontmatter of the blog posts. This keeps your source code organized and will be important for later steps. For now, the next step is to install and configure the plugins that are required for Gatsby to process this new Markdown post.

      Step 2 — Installing and Configuring the Required Plugins

      With your Markdown file in place, it is time to tell Gatsby where to find them and process them. In this step, you will install the plugins that are required to achieve this and update the Gatsby configuration to load them.

      Two plugins are required to process Markdown in Gatsby: gatsby-transformer-remark and gatsby-source-filesystem. gatsby-transformer-remark will parse your Markdown and convert your frontmatter into fields that Gatsby can query, and gatsby-source-filesystem will allow you to bring data from your local filesystem into your application.

      Install both at the same time by running the following command in your Gatsby project directory:

      • npm install gatsby-source-filesystem gatsby-transformer-remark

      After you install both plugins, open up the main Gatsby configuration file that lives in the root of your project folder: gatsby-config.js. By editing this file, you are telling Gatsby how to use the newly installed plugins to read your Markdown files and begin processing them. Add the following code to your config file:

      markdown-tutorial/gatsby-config.js

      module.exports = {
      ...
        plugins: [
          `gatsby-plugin-react-helmet`,
          `gatsby-plugin-image`,
          {
            resolve: `gatsby-source-filesystem`,
            options: {
              name: `images`,
              path: `${__dirname}/src/images`,
            },
          },
          {
            resolve: `gatsby-source-filesystem`,
            options: {
              name: `blog`,
              path: `${__dirname}/src/blog`,
            },
          },
          `gatsby-transformer-remark`,
          `gatsby-transformer-sharp`,
      ...
      

      The first block loads the gatsby-source-filesystem plugin and passes it an options object telling it to scan the src/blog directory for files and use the blog name as a label for the collection. The final line loads the gatsby-transformer-remark plugin with all default options, since you don’t need to customize them for this tutorial.

      You have now configured Gatsby to load the two plugins that are necessary for scanning in and parsing your Markdown files. In the next step, you will create a page template file for Gatsby to combine with your Markdown content and render as web pages.

      Step 3 — Creating a Page Template File

      Gatsby will now scan your Markdown files and process them with gatsby-transformer-remark, but it still needs instructions on how to display them in the browser. This step covers how to give it those instructions by adding a page template file (also known as a page template component).

      First, create an empty file in src/pages with a filename of {MarkdownRemark.frontmatter__slug}.js. The filename needs to exactly match this, because it uses a Gatsby API called the File System Route API, in which filenames dictate the routes (URLs) created on your site.

      Note: The File System Route API is a newer feature in Gatsby, and you might still see other Markdown page tutorials that involve the createPages API in gatsby-node.js instead. Although it is not deprecated, that API is no longer necessary for the use case covered by this tutorial. However, if you have a project that involves creating arbitrary pages that don’t mirror the file system or exceeds the capabilities of the File System Route API in some other way, you might still need to use the createPages approach.

      To create your component, add the following code to the file:

      markdown-tutorial/src/pages/{MarkdownRemark.frontmatter__slug}.js

      import { graphql } from "gatsby";
      import * as React from "react";
      import Layout from "../components/layout";
      import Seo from "../components/seo";
      
      export default function BlogPostTemplate({ data: { markdownRemark } }) {
        const { frontmatter, html } = markdownRemark;
        return (
          <Layout>
            <Seo title={frontmatter.title} />
            <h1>{frontmatter.title}</h1>
            <h2>{frontmatter.date}</h2>
            <div className="post-body" dangerouslySetInnerHTML={{ __html: html }} />
          </Layout>
        );
      }
      
      export const pageQuery = graphql`
        query ($id: String!) {
          markdownRemark(id: { eq: $id }) {
            html
            frontmatter {
              date(formatString: "MMMM DD, YYYY")
              title
            }
          }
        }
      `;
      

      This code has two main sections. The one at the end of the file is pageQuery, which uses the Gatsby GraphQL tag to evaluate the GraphQL query that follows it. The results of that query are passed to the BlogPostTemplate function and give you access to properties of the post fetched over GraphQL.

      The BlogPostTemplate function is a React component that returns JSX. Within the BlogPostTemplate you display the values of each post’s standardized frontmatter fields, the title and the date, in header elements. The actual body of the post you have placed into a <div> with a class of post-body, using React’s dangerouslySetInnerHTML property to directly echo out the HTML into the rendered result.

      Finally, using export default before declaring the BlogPostTemplate function is necessary in your code, because Gatsby will expect the default export of each page template file to be the React component responsible for producing the final rendered page.

      Now that you have added the template code to the file, save the changes and close it.

      In completing this step, you added a brand new page template file to your Gatsby project. With a filename that uses the File System Route API, it dynamically creates routes and pages based on GraphQL results and your Markdown source files. This was the final step to get Gatsby to generate pages from Markdown. In the next step, you will see these pages in action, as well as add new ones.

      With all the code now in place to turn your Markdown blog posts into web pages, you can now preview your work and add more Markdown content to your site.

      To preview your new blog posts and all the work you have done so far, run this command in your project directory:

      Once Gatsby is ready, it will prompt you to open your project in your web browser, which you can do by navigating to localhost:8000. However, this will first only show you the homepage of your Gatsby application instead of the blog post. To see your new Markdown blog post, navigate to localhost:8000/blog/learning-about-gatsby/. You will find your Markdown file rendered as HTML:

      Blog post titled

      From now on, you can continue to add new blog posts by creating Markdown files in the src/blog directory. Each time you create a new post, remember to follow the conventions you set up for your frontmatter. This means making sure to start the slug value with /blog/ followed by the custom path you want, as well as providing the post with a title and date.

      To test this out, copy your learning-about-gatsby.md Markdown file to be the base of a new post named continuing-learning.md:

      • cp src/blog/learning-about-gatsby.md src/blog/continuing-learning.md

      Next, open the new file and make the following highlighted changes to the content:

      markdown-tutorial/src/blog/continuing-learning.md

      --- 
      title: "Continuing to Learn"
      slug: "/blog/continuing-learning"
      date: "2021-08-01" 
      --- 
      
      ## Update
      
      I'm continuing to learn Gatsby to build some fast static sites!
      

      In this file, you kept the formatting the same but changed the title and slug of the frontmatter and the content of the blog post. Save the file then exit from it.

      Once your server has rebuilt your Gatsby site, navigate to http://localhost:8000/blog/continuing-learning in your browser. You will find the new post rendered at this URL:

      Blog post titled

      Note: If you wanted to add Markdown pages outside of blog, you could do so by modifying the slug to whatever path you would like. If you do this, make sure to use folders to keep your files organized.

      You now have new pages generated from Markdown in Gatsby and have previewed the results.

      Conclusion

      By following the steps in this tutorial, you added Markdown content to your Gatsby project, configured Gatsby to find the files and process them, and created template code to render each post as a new page. Although some of these steps could be omitted by using a Markdown-specific Gatsby Starter template, going through the process manually allows you to customize your Markdown-powered Gatsby site exactly how you want it.

      Although you can link to any new post or page using the Gatsby Link component, if your site has a large amount of Markdown files that are rapidly changing you might want to explore adding a dynamic listing as a next step, so visitors to your site can quickly find all your most recent posts and navigate to each one. To do so, you could use a Gatsby GraphQL tag to query the Markdown posts you want to list, and then iterate over them and display them as links. You can read more about this in this Adding a List of Markdown Blog Posts tutorial.

      If you would like to read more on Gatsby, check out the rest of the How To Create Static Web Sites with Gatsby.js series.



      Source link

      How To Speed Up Static Web Pages with Varnish Cache Server on Ubuntu 20.04


      The author selected the COVID-19 Relief Fund to receive a donation as part of the Write for DOnations program.

      Introduction

      Varnish is a versatile reverse HTTP proxy that caches responses from backend servers in memory so they are served quickly when requested again. It uses HTTP headers to determine whether to cache the responses to a particular request. By default, it does not cache responses with cookies because those are considered client-specific requests; however you can change this setting in the configuration file.

      Besides acting as a caching server, Varnish can be used as a:

      • Web application firewall
      • DDoS attack defender
      • Load balancer
      • Quick fix for unstable backends
      • HTTP router

      There are three locations where the HTTP cache can be saved:

      • Browser: This cache is saved on users’ browsers. It is user-specific and can be used to serve content instead of sending requests to web sites.
      • Proxy: A proxy is an intermediate server that sits between users and servers. It is usually deployed by ISPs and can be used to cache responses that will be requested by multiple users.
      • Reverse Proxy: This kind of proxy is created by the web site’s administrator and can be used to serve content from the network’s edge instead of sending requests to back end servers. This is the kind of cache you will create in this tutorial.

      Note: For more information about HTTP caching, see this tutorial on HTTP headers and caching strategies.

      In this tutorial, you will set up Varnish as a caching reverse proxy server. You’ll then test the setup with Varnish against a non-caching configuration using wrk.

      Prerequisites

      To complete this tutorial, you will need:

      Step 1 — Installing Varnish And Apache

      To start, you’ll install Apache and Varnish. First update apt-get, and then install Apache with these commands:

      • sudo apt-get update
      • sudo apt-get install apache2 -y

      You’ll see output indicating that Apache is being installed.

      After the Apache installation process is complete, install Varnish with this command:

      • sudo apt-get install varnish -y

      You’ll see output indicating that Varnish is being installed.

      Next, make sure both packages installed correctly. First, use this command to check the status of Apache:

      • sudo systemctl status apache2

      The output will look similar to this:

      Output

      root@ubuntu-s-1vcpu-2gb-fra1-01:~# sudo systemctl status apache2 ● apache2.service - The Apache HTTP Server Loaded: loaded (/lib/systemd/system/apache2.service; enabled; vendor preset: enabled) Active: active (running) since Wed 2021-08-04 18:58:39 UTC; 4min 10s ago Docs: https://httpd.apache.org/docs/2.4/ Main PID: 2279 (apache2) Tasks: 55 (limit: 2344) Memory: 5.0M CGroup: /system.slice/apache2.service ├─2279 /usr/sbin/apache2 -k start ├─2281 /usr/sbin/apache2 -k start └─2282 /usr/sbin/apache2 -k start Aug 04 18:58:39 ubuntu-s-1vcpu-2gb-fra1-01 systemd[1]: Starting The Apache HTTP Server... Aug 04 18:58:39 ubuntu-s-1vcpu-2gb-fra1-01 apachectl[2278]: AH00558: apache2: Could not reliably determine the server's fully qualified domain name, using 127.0.1.1. Set the 'ServerName' di> Aug 04 18:58:39 ubuntu-s-1vcpu-2gb-fra1-01 systemd[1]: Started The Apache HTTP Server.

      Press the Q key to exit the status command.

      Next, check the status of Varnish with this command:

      • sudo systemctl status varnish

      The output will look similar to this:

      Output

      root@ubuntu-s-1vcpu-2gb-fra1-01:~# sudo systemctl status varnish ● varnish.service - Varnish HTTP accelerator Loaded: loaded (/lib/systemd/system/varnish.service; enabled; vendor preset: enabled) Active: active (running) since Wed 2021-08-04 18:59:09 UTC; 4min 41s ago Docs: https://www.varnish-cache.org/docs/6.1/ man:varnishd Main PID: 3423 (varnishd) Tasks: 217 (limit: 2344) Memory: 10.7M CGroup: /system.slice/varnish.service ├─3423 /usr/sbin/varnishd -j unix,user=vcache -F -a :6081 -T localhost:6082 -f /etc/varnish/default.vcl -S /etc/varnish/secret -s malloc,256m └─3447 /usr/sbin/varnishd -j unix,user=vcache -F -a :6081 -T localhost:6082 -f /etc/varnish/default.vcl -S /etc/varnish/secret -s malloc,256m Aug 04 18:59:09 ubuntu-s-1vcpu-2gb-fra1-01 systemd[1]: Started Varnish HTTP accelerator. Aug 04 18:59:10 ubuntu-s-1vcpu-2gb-fra1-01 varnishd[3423]: Debug: Version: varnish-6.2.1 revision 9f8588e4ab785244e06c3446fe09bf9db5dd8753 Aug 04 18:59:10 ubuntu-s-1vcpu-2gb-fra1-01 varnishd[3423]: Version: varnish-6.2.1 revision 9f8588e4ab785244e06c3446fe09bf9db5dd8753 Aug 04 18:59:10 ubuntu-s-1vcpu-2gb-fra1-01 varnishd[3423]: Debug: Platform: Linux,5.4.0-73-generic,x86_64,-junix,-smalloc,-sdefault,-hcritbit Aug 04 18:59:10 ubuntu-s-1vcpu-2gb-fra1-01 varnishd[3423]: Platform: Linux,5.4.0-73-generic,x86_64,-junix,-smalloc,-sdefault,-hcritbit Aug 04 18:59:10 ubuntu-s-1vcpu-2gb-fra1-01 varnishd[3423]: Debug: Child (3447) Started Aug 04 18:59:10 ubuntu-s-1vcpu-2gb-fra1-01 varnishd[3423]: Child (3447) Started Aug 04 18:59:10 ubuntu-s-1vcpu-2gb-fra1-01 varnishd[3423]: Info: Child (3447) said Child starts Aug 04 18:59:10 ubuntu-s-1vcpu-2gb-fra1-01 varnishd[3423]: Child (3447) said Child starts

      If you do not see both services up and running, wait a few minutes until they are fully loaded, and keep both of them running.

      Now that you have Apache2 Varnish, installed, you’ll give Varnish something to serve, in this case Apache’s static web page.

      Step 2 — Configuring Varnish To Serve Apache’s Static Web Page

      In the previous step, you installed Varnish, and next you’ll need to configure it. By default, Varnish listens on port 6081 and connects to a local web server on port 8080. You’ll change that to serve the Apache static site from Apache server.

      First, you’ll change Varnish’s listening port to 8080. Usually you would want the listening port to be 80, but because you are running Apache and Varnish on the same server, you’ll use port 8080 for Varnish and port 80 for Apache.

      There is no configuration option to change the listening port for Varnish, so you’ll do it using the command line. You’ll create a file called customexec.conf in a new directory called varnish.service.d in /etc/systemd/system/ that will change the default ports.

      Use the mkdir command to create the new directory:

      • sudo mkdir /etc/systemd/system/varnish.service.d

      Use your favorite text editor to create a new file called customexec.conf :

      • sudo nano /etc/systemd/system/varnish.service.d/customexec.conf

      In customexec.conf, add the following content:

      /etc/systemd/system/varnish.service.d/customexec.conf file

      [Service] ExecStart= ExecStart=/usr/sbin/varnishd -j unix,user=vcache -F -a :8080 -T localhost:6082 -f /etc/varnish/default.vcl -S /etc/varnish/secret -s malloc,256m

      In this file you are changing the Service section of the Varnish configuration. First you remove the old value for the ExecStart option, and then you assign a new value for it.

      The new value specifies the binary file used to run Varnish with the following options:

      • -j: Specifies the jailing mechanism to use. Varnish jails are used to reduce the permissions for the varnish process over various platform-specific methods. Here you’re using the unix mechanism and the user vcache to limit the permissions. This is default for varnish on Ubuntu systems.

      • -F: Indicates that the server should run in the foreground, because systemd expects the main process to keep running so it can track it, and not fork a new process and die.

      • -a: This flag is used to specify the IP address and port for accepting client connections. The IP in this case is empty, which means the server will accept all IPs. The port is set to 8080.

      • -T: This flag specifies the IP address and port for management interface, in this case localhost and port 6082.

      • -f: This flag specifies the default VCL file for Varnish configuration. You will edit this file later in this tutorial to configure Varnish to connect to the Apache server.

      • -S: This flag specifies a shared secret file for authorizing access to the management interface. The /etc/varnish/secret value is the default for Varnish on Ubuntu. You will not use the secret file in this tutorial.

      • -s: This flag indicates where and how to store objects. The value malloc,256m is the default one for Vanish. It means to store various Varnish objects in memory using the malloc system call and a maximum size of 256 megabytes. Other possible values are default, which uses umem when malloc is not available, or file, which stores objects in a file on the disk.

      Save and close the customexec.conf file. Then execute this command to reload the systemd services file from disk:

      • sudo systemctl daemon-reload

      Then restart Varnish for changes to take effect.

      • sudo systemctl restart varnish

      You won’t see any output from these last two commands. To make sure that Varnish is now listening on port 8080, use the netstat command to display all listening TCP sockets on the server.

      • sudo netstat -ltnp | grep 8080

      You’ll see output that looks like this:

      Output

      tcp 0 0 0.0.0.0:8080 0.0.0.0:* LISTEN 18689/varnishd tcp6 0 0 :::8080 :::* LISTEN 18689/varnishd

      Now that Varnish is running and listening to port 8080, you need to edit the default configuration file located at /etc/varnish/default.vcl:

      • sudo nano /etc/varnish/default.vcl

      Navigate to the backend default block, and then change .port to 80, as shown here:

      default.vcl file

      # Default backend definition. Set this to point to your content server. backend default { .host = "127.0.0.1"; .port = "80"; }

      Save and close the default.vcl file, then restart Varnish with this command:

      • sudo systemctl restart varnish

      If everything is fine, there won’t be any output. Open http://your_server_ip:8080 in your browser, and you’ll see the Apache static site, opened using Varnish.

      You now have Apache and Varnish running together on the same Droplet, with Apache listening to port 80 and Varnish to port 8080. Next, you’ll compare the response times of both servers using the wrk tool.

      Step 3 — Testing Varnish Using wrk

      wrk is a modern HTTP benchmarking tool. It is written in C, and can be used to load test web servers with many requests per second. In this step, you’ll use wrk to run tests against Apache and Varnish and then compare the results.

      First you’ll need to install wrk by building it from source. Start by installing some build tools for C and git, which are required for building wrk from source:

      • sudo apt-get install build-essential libssl-dev git unzip -y

      Then clone the git repository for wrk into the wrk directory:

      • git clone https://github.com/wg/wrk.git wrk

      Change to that new directory:

      Build the wrk executable with the make command:

      Copy wrk to the /usr/local/bin directory so you can access it from anywhere in your directory structure:

      • sudo cp wrk /usr/local/bin

      Now that you have wrk installed, use it to test the responsiveness of Apache with this command:

      • wrk -t2 -c1000 -d30s --latency http://server_ip/

      This command uses the following arguments:

      • -t2: This means run two threads.
      • -c1000: Keep 1000 HTTP connections open.
      • -d30s: Run the test for 30 seconds.
      • --latency: Print latency statistics.

      Wait 30 seconds until the test is done, and you’ll see output similar to this:

      output

      Running 30s test @ http://68.183.115.151/ 2 threads and 1000 connections Thread Stats Avg Stdev Max +/- Stdev Latency 44.45ms 104.50ms 1.74s 91.20% Req/Sec 8.29k 1.07k 12.40k 71.00% Latency Distribution 50% 11.59ms 75% 22.73ms 90% 116.16ms 99% 494.90ms 494677 requests in 30.04s, 5.15GB read Socket errors: connect 0, read 8369, write 0, timeout 69 Requests/sec: 16465.85 Transfer/sec: 175.45MB

      In this test, the average latency is 44.45ms, there were 494,677 total requests, 8,369 read errors, and 69 timeout errors. The exact numbers will vary in your installation.

      Now run the same test again for the Varnish server using this command:

      • wrk -t2 -c1000 -d30s --latency http://server_ip:8080/

      Wait 30 seconds until the test is done, and you’ll see output similar to this:

      output

      Running 30s test @ http://68.183.115.151:8080/ 2 threads and 1000 connections Thread Stats Avg Stdev Max +/- Stdev Latency 14.41ms 13.70ms 602.49ms 90.05% Req/Sec 6.67k 401.10 8.74k 83.33% Latency Distribution 50% 13.03ms 75% 17.69ms 90% 24.72ms 99% 58.22ms 398346 requests in 30.06s, 4.18GB read Socket errors: connect 0, read 19, write 0, timeout 0 Requests/sec: 13253.60 Transfer/sec: 142.48MB

      The output you see will likely be somewhat different, but the latency will be lower for Varnish than for Apache. In this case, the average latency is 14.41ms, there were 398,346 total requests, and no errors.

      In these tests, with Apache the average response time was 44.45ms with 8,438 errors, while Varnish achieved an increase in speed to 14.41ms, and also had no errors. This is because Varnish cached the response in memory and served it for later requests, unlike Apache, which needs to read from disk almost every time the resource is requested.

      Conclusion

      In this tutorial, you configured Varnish as a reverse proxy caching server for a static web site. You saw how to use basic HTTP caching to improve performance, and you used wrk to run load tests for the Apache and Varnish servers to compare the results.

      You’ve seen that the Varnish cache server speeds up your static site by serving content from main memory and not requesting it from the back end Apache server every time a new request arrives. For more information about other uses of Varnish, see the official documentation.



      Source link

      17 Great About Us Pages to Inspire You


      Every business needs a website. And every website needs an About Us page.

      Actually . . . take two steps back.

      Let’s revise that.

      Every website needs a unique and exciting About Us page that compels visitors to buy your product or service.

      Stick with us, and we’ll look at what an About Us page is and why you need one. More importantly, we’ll discuss how to create compelling About Us pages that build trust, increase conversions, and boost retention rates.

      After that? We’ll dip into 17 examples of unique and exciting About Us pages and delve into what it is about them that makes them worth a special mention.

      We’ll Support Your Dream

      Whatever your online goals, we’ll be right there with you, making sure your site is fast, secure, and always up. Plans start at $2.59/mo.

      What Is an ‘About Us’ Page?

      In short, it’s a page that serves to inspire people — either to work with you or to buy your product. It can contain (but isn’t limited to containing) your brand story, your achievements, and your best testimonials.

      What Is an ‘About’ Page Not?

      An About page is not a page for pushing a hard sell or a page for boasting about your business. It should offer an up-front and honest portrayal of your company, its story, and your brand values.

      So when creating an About Us page, you should make sure to:

      • Stay away from the hype. Users can see straight through it. Leave it for social media.
      • Avoid a sales pitch. If a reader is on your About Us page, there’s a good chance they’re considering using your service or buying your product. They’re looking at why they should choose you. So don’t sell your product or service. Sell you.

      Why?

      It’s simple: People work with people, and people buy from people.

      Tips For Making Great ‘About Us’ Pages

      You should now have a decent idea of what an About Us page should and shouldn’t contain.

      We’re going to follow this with a few tips to help you stand out and create an About Us page that works for you and your business.

      • Be creative. Don’t fall into the trap of simply writing a brief summary of your business and calling it a day. The best About Us pages are creative, informative, and interesting.
      • Don’t follow the crowd. If someone’s reading your About page, there’s a good chance they’ve been reading (or will read) your competitors’ About Us pages. So, make sure your page stands out. It should make it almost impossible for a potential customer to forget you.
      • Feature faces. Consumers like to know who they’re buying from or working with, so make sure to feature at least some of your team on your About page. It can really help boost conversions.

      Oh, and never use stock photography. Ever.

      • Be transparent. Your About Us page serves to sell your story and get buy-in from your visitors. Transparency is incredibly important to win your visitors’ trust.
      • Don’t forget about CTAs. Like any other page, About Us pages need calls to action. Many sites seem to forget that this is a key page for converting visitors. Make it clear to readers what you want them to do next.

      How To Make An ‘About Us’ Page That Converts

      1. Keep your copy simple.

      Don’t litter the page with industry jargon and confusing copy. The words should leap off the page and inspire your visitors to take action. A block of text that visitors have to read six times to grasp is not going to cut the mustard.

      2. Make sure your contact details are on the page.

      This might seem obvious. However, we dug through countless About Us pages while researching this article, and you’d be surprised at how many we came across that didn’t contain contact details or even a contact form.

      If a visitor’s got as far as looking at your About Us page, there’s a good chance they’re thinking of working with you or using your service. Don’t miss that opportunity to convert them by making them search for a separate contact page.

      3. Put yourself in the readers’ shoes.

      What do you think they are looking for? What do they need to know? Many About Us pages don’t seem to have considered these things. At all.

      Does your page highlight your skills? Your knowledge? Your experience? Does it explain to readers the benefits of using your service or products? Does it reference your USPs?

      4. Don’t be afraid to use visuals.

      Consumers today are used to things being delivered fast. Whether it’s a product they’ve ordered or, in this case, information.

      Are you able to sell your service or business in visuals and words? The human brain processes images much faster than words, so if you can, use both.

      5. Include customer testimonials.

      Trust in your brand is essential. Testimonials from genuine customers are a massive selling point and can help convert prospective clients into actual, revenue-generating customers.

      Fancy going one step further?

      Alongside customer testimonials, include quotes or endorsements from influencers or industry experts (if you can get them, of course).

      6. Tell a story.

      Tell your company’s history, but in a way that compels visitors to keep reading. Who doesn’t love a good story? Stories get visitors more invested in your brand. And that, naturally, leads to more conversions.

      Bonus points if you can craft a more personal story.

      7. Make sure the page loads fast.

      This, of course, goes for every page on your site, but it’s crucial that key conversion pages load as fast as possible. Make sure to talk to your web developer and emphasize the importance of page load speed.

      You can find out exactly how long a particular page of your site takes to load and what can be done to make it load faster with Google’s PageSpeed Insights.

      8. Don’t forget the fold.

      Ideally, all important information should be positioned above the fold. You should also guide users to scroll down and read more.

      9. And mobile usability.

      While it varies from industry to industry, more than half of internet browsing now takes place on mobile devices. So make sure your About Us page, and your site as a whole, is built for mobile first.

      You can check if a page is mobile-friendly using Google’s Mobile-Friendly test.

      17 ‘About Us’ Pages That Get It Right — And Why

      Are you in need of some inspiration to help you build your ideal About Us page? Look no further. We’ve scoured the Internet to find some of the best About Us pages out there.

      No matter your niche or what kind of business you run, you’ll be able to find some inspiration in these 17 examples.

      Let’s take a look at each one and discover what makes these pages so unique and exciting (and worthy of inclusion on this list).

      1. HERoines Inc.

      The HERoines Inc. About Us page

      What makes this a good About Us page?

      • The page itself is simple and aesthetically pleasing, and it loads fast.
      • It features photos of the team that seamlessly fit into the page design.
      • The colors and tones used match the rest of the site, creating consistency across all pages.
      • It covers the brand’s visions and goals using inspirational, engaging copywriting.
      • The CTA button sits to the right of the page and remains visible at all times.

      2. Iconiq Creative

      The Iconiq Creative About Us page.

      What makes this a good About Us page?

      • It’s free of unnecessary words and gets straight to the point.
      • It features case studies, a client list, and their credentials — all in plain sight, for all to see.
      • They feature multiple testimonials (although this could be improved by slowing down the carousel or giving users the ability to scroll at their own speed).
      • They’ve linked to their founder’s website, so visitors can learn even more about the brand and its history.
      • It showcases their humanitarian work in a “Giving & Causes” section.

      3. RubyLove

      The RubyLove About Us page

      What makes this a good About Us page?

      • The copy is upfront, accessible, and fun — despite the brand selling products that (sadly) still have some stigma attached to them.
      • It sets out their mission from the first sentence.
      • It’s not always a wise idea to sell on your About Us page; however, this site succeeds by soft-selling using videos, great imagery, and natural internal linking.
      • It features a section that boldly states the benefits of their products and how they can help you. In other words, the copy is user-centric.

      4. Band

      Band’s About Us page.

      What makes this a good About Us page?

      • As a creative studio, this About Us page demonstrates that knowing your user is crucial. The page kicks off with some fantastic imagery that reinforces their business mission.
      • The copy is minimal but covers what’s needed: who they are, why they exist, and why you should work with them.

      5. Anton & Irene 

      Anton & Irene About Us page.

      What makes this a good About Us page?

      • This is one of the best one-page websites we found. Anton and Irene have effectively turned their entire site into an About Us page. It’s edgy and daring and, well, pretty unforgettable.
      • The photography for the team (just the two of them) is incredibly creative. When you hover over their figures, snippets of what’s beneath the veneers are revealed. This one definitely isn’t following the crowd. Exactly what a design brand needs.
      • It tells you who they are and what they do using one sentence and a few bullet points. In other words, it’s minimalist and to the point, while letting the user know exactly how Anton and Irene can help them.
      • It features where they’ve appeared and what they’ve achieved, and it breaks it down into fun sections using hard facts (with a side of cheeky humor).
      • Their contact information is some of the most detailed on this list, but it doesn’t feel tedious or over-the-top. It has that human touch. Largely because they’ve injected their personality into the entire page.
      • They top it off by featuring testimonials and highlighting the awards they’ve won — and they manage this without sounding like they’re giving you a sales pitch.

      6. LessFilms

      The LessFilms About Us page.

      What makes this a good About Us page?

      • They understand their target audience. As a video production company, they (understandably) use video to tell their brand story, and they do it in less than a minute.
      • Everything else is kept to a minimum — they inject a little humor using bullet points that articulate who they are in less than 20 words. To top it off, they have a team member section that makes you feel like you know them personally. The page makes it almost impossible not to want to work with them.

      7. Mailchimp

       The Mailchimp About Us page.

      What makes this a good About Us page?

      • Despite being a big company, Mailchimp successfully manages to circumvent any corporate tropes. Instead, their About Us page makes you feel like you’re going to be working with a small team.
      • Each section is only a couple of paragraphs long. Despite having a ton to talk about, Mailchimp understands that the reader only needs top-level ideas (though you can go off and learn more, thanks to dedicated pages for the company’s culture and history).
      • At no point does the page feel like a sales pitch. It simply pulls you into what Mailchimp stands for and who they are as a company.

      8. 500px

      The 500px About Us page.

      What makes this a good About Us page?

      • As an online network for photographers, you would expect great visuals on their About page, and it doesn’t disappoint — especially if you happen to be a dog person!
      • The page goes on to explain who they are and their commitment to their network. Plus, it’s completely free of fluff.
      • It sets out the benefits of joining the network, and it does it clearly and concisely.

      9. GIPHY

      The GIPHY About Us page.

      What makes this a good About Us page?

      • If you’ve ever used a Graphics Interchange Format file (aka a GIF), then you’re probably aware of GIPHY. GIFs are fun. So GIPHY should be too. And they certainly haven’t let us down. They’ve seemingly taken their ethos, worked from the ground up, and created an About Us page that’s quirky, engaging, and completely on point when it comes to reflecting the brand and its identity.
      • And it’s pretty much done entirely using — you guessed it — GIFs.

      10. Twitter

      Twitter’s About Us page.

      What makes this a good About Us page?

      • Twitter’s About page hits the nail on the head when it comes to copy with brevity. It lays out who they are and what they stand for without going into too much detail. You know precisely what you’re going to get from the social network just by looking at their About Us page.
      • It does an excellent job of moving visitors down the funnel and getting them to sign up and start using the site. They do this in part by pulling trending content into the page. This gives readers a CTA to try the platform.

      11. Moz

      The Moz About Us page.

      What makes this a good About Us page?

      • Moz is known for its transparency, and this shines through in their About Us page. It’s honest, to the point, and tells you their entire story — but without dragging on or going into unnecessary detail.
      • The page also acknowledges their faults and when and why that had to pivot their products to survive in their niche. This is pretty unique and impressive. Not all companies are so honest.

      12. Cupcakes and Cashmere

      The Cupcakes and Cashmere About Us page.

      What makes this a good About Us page?

      • While Emily’s adopted a more traditional approach, this About Us page clearly conveys who Cupcakes and Cashmere are and what they do.
      • They do this using a set of strong visuals that show there are real people behind the brand with a legitimate mission.
      • The site also includes a comprehensive FAQ section where pretty much every question a reader could have is answered — right down to how their affiliate links work.

      13. Eight Hour Day

      The Eight Hour Day About Us page.

      What makes this a good About Us page?

      • This is another creative studio that successfully reflects the quality of their work with a simple About Us page that doesn’t beat around the bush.
      • They tell you who they are, what they do and why they do it, and who they’ve worked with.
      • And they do it all on one page, using clear, concise, and engaging copy.

      14. National Geographic 

      The National Geographic About Us page.

      What makes this a good About Us page?

      • Creating a more corporate About Us page that doesn’t feel stuffy and stagnant isn’t easy, but National Geographic manages to pull it off. The page begins with an inspiring video that’s right on-brand.
      • The page then discusses their mission, alongside information about their leadership team. It also features a job board.
      • Finally, they point you towards some of their most recent content — essentially a fairly subtle CTA.

      15. Cultivated Wit

      The Cultivated Wit About Us page.

      What makes this a good About Us page?

      • As a comedy company, you’d expect their About Us page to be on the playful side. Cultivated Wit hasn’t let their visitors down. They’ve delivered engaging copy that articulates their mission statement in just a few hundred words.
      • Cultivated Wit also uses well-chosen team imagery that makes it crystal clear who they are and how they work.

      16. Lonely Planet

      The Lonely Planet About Us page.

      What makes this a good About Us page?

      • If you’re reading the About Us page on Lonely Planet, you probably already know what they do — and Lonely Planet gets this. So, instead of preaching to the choir, the focus is on how their site can help the user.
      • This page demonstrates the importance of design when it comes to an About Us page using stunning visuals and incredible design. Every part oozes class.

      17. GummiSig

      The GummiSig About Us page.

      What makes this a good About Us page?

      • Gummisig is a freelance web designer, so we’d hope they’d know how to put a good About page together. Thankfully, this one doesn’t disappoint. From the start, you know you’re on a quality page when you see the text, “Who is this man? Dude, myth or mega designer.”
      • Gummisig also shows how important it is to inject your personality into your About page. The copy reflects this perfectly, so readers can get a real feel for who they’ll be working with.

      Ready to Create a Stellar About Us Page?

      Whether you need help writing a mission statement, creating a marketing strategy, or boosting your conversion rate, we can help! Subscribe to our monthly digest so you never miss an article.

      So, What’s Your Value Proposition?

      As you might have noticed, there’s no one set way to design an effective About Us page. Pages can be casual or corporate. Silly or serious. Image-led or copy-led. Or both.

      Throughout all these pages, the running theme is that they engage, educate, and entice readers to become customers. They’re also an accurate reflection of the brands, and leave users feeling that little bit closer to the company — as well as the people behind it.

      Create an About Us page that ticks these boxes, and you may well find you’re converting more customers (and better quality customers) with minimal extra effort.

      Good luck, and more importantly, have fun!





      Source link