diff --git a/app/assets/images/tutorials/jwt-auth/jwt-auth-output.png b/app/assets/images/tutorials/jwt-auth/jwt-auth-output.png
index 082c96a57f..b218ecf511 100644
Binary files a/app/assets/images/tutorials/jwt-auth/jwt-auth-output.png and b/app/assets/images/tutorials/jwt-auth/jwt-auth-output.png differ
diff --git a/app/assets/stylesheets/live-demo.scss b/app/assets/stylesheets/live-demo.scss
new file mode 100644
index 0000000000..524f7c9c6f
--- /dev/null
+++ b/app/assets/stylesheets/live-demo.scss
@@ -0,0 +1,58 @@
+/* styles for live demo container */
+
+.live-demo-container {
+  background: #efefef;
+  padding: 2rem;
+  margin: 0 0 2rem 0;
+
+  input {
+    border: 1px solid;
+    padding: 0.7rem 1rem;
+    margin-bottom: 0.15rem;
+    display: block;
+    width: 50%;
+    border-radius: 3px;
+  }
+
+  button {
+    border: 1px solid;
+    padding: 1rem 1rem;
+    background: black;
+    color: white;
+    padding: 10px 30px;
+    display: block;
+    border-radius: 5px;
+    margin: 0.5rem 0 2rem 0;
+    font-weight: 700;
+  }
+
+  button:hover {
+    background: #ff5416;
+  }
+
+  textarea {
+    padding: 0;
+    margin: 0;
+    width: 100%;
+    font-family: monospace;
+    background-color: #232323;
+    color: #00ff33;
+    line-height: 1.5;
+    display: block;
+    border: none;
+  }
+
+  label {
+    color: black;
+    display: block;
+    margin: 0.5rem 0;
+    font-weight: 700;
+  }
+}
+
+.live-demo-response {
+  padding: 1rem;
+  margin: 0;
+  background-color: #232323;
+  border-radius: 3px;
+}
diff --git a/app/assets/stylesheets/stylesheet.scss b/app/assets/stylesheets/stylesheet.scss
index 5ecf69c243..a1699c70a3 100644
--- a/app/assets/stylesheets/stylesheet.scss
+++ b/app/assets/stylesheets/stylesheet.scss
@@ -4,4 +4,5 @@
 @import "minimizable";
 @import "flashbox";
 @import "sidebar";
-@import 'redoc';
+@import "redoc";
+@import "live-demo";
diff --git a/content/tutorials/jwt-authentication.textile b/content/tutorials/jwt-authentication.textile
index d56825efab..d3c9cb6418 100644
--- a/content/tutorials/jwt-authentication.textile
+++ b/content/tutorials/jwt-authentication.textile
@@ -10,15 +10,15 @@ authors:
   author_profile_url: https://github.com/tbedford
 category:
 - channels
-date_published: '2018-04-25T16:49:28+02:00'
 excerpt: Learn how to issue Ably JWTs for your users, configure their capabilities
   (permissions) and authenticate clients using these tokens
 group: sdk
 index: 55
+date_published: '2018-04-25T16:49:28+02:00'
+last_updated: '2022-08-10T09:35:45+00:00'
 languages:
 - javascript
 - nodejs
-last_updated: '2022-01-12T09:35:45+00:00'
 level: medium
 platform: browser
 reading_time: 20
@@ -33,74 +33,82 @@ meta_keywords: "Ably realtime, JWT, authentication"
 
 This tutorial guides you through the process of creating a simple authentication server that generates a "JSON Web Token (JWT)":/core-features/authentication#token-authentication. You'll see how the client can use this JWT to authenticate with Ably. You will also learn how the client can automatically request a new JWT, before the current JWT expires.
 
-Ably supports two types of authentication schemes: 
+Ably supports two types of authentication schemes:
 
-* "Basic authentication":/core-features/authentication#basic-authentication - this uses one of your private API keys and is designed for use by your servers. 
+* "Basic authentication":/core-features/authentication#basic-authentication - this uses one of your private API keys and is designed for use by your servers.
 * "Token authentication":/core-features/authentication#token-authentication - can be used by your device and browser clients. A short-lived secure token is issued to these clients by your auth server. "JSON Web Token (JWT) authentication":/core-features/authentication#token-authentication is an extension of the token-based authentication scheme in Ably.
 
 When using token authentication, Ably recommends you instantiate the client library with a method to obtain tokens, rather than a token itself. This is due to the fact that tokens eventually expire, resulting in the connection being lost. By providing a method to obtain tokens instead, the Ably client library will automatically get a new token once the current one expires, maintaining a continuous connection.
 
 "JSON Web Tokens":https://jwt.io/ (JWTs) are an open, industry standard (RFC 7519) method for representing claims securely between two parties. JWT auth is especially helpful in scenarios where a single authentication scheme is to be used for all devices and browsers, and third-party platforms such as Ably. JWT auth is also a convenient way to authenticate your IoT devices or servers which are built using the platforms that Ably doesn't yet support. This is possible because you don't have to instantiate an Ably client when using the JWT auth scheme.
 
-Ably offers two different ways in which you can use a JWT to authenticate your users: 
+Ably offers two different ways in which you can use a JWT to authenticate your users:
 
-* You can use the JWT as the token itself by formatting it correctly (called an Ably JWT). 
-* You can pass to Ably a JWT of any structure that contains an Ably Token. 
+* You can use the JWT as the token itself by formatting it correctly (called an Ably JWT).
+* You can read the "specification of the Ably JWT token":https://ably.com/docs/api/realtime-sdk/authentication#ably-jwt if you want to understand its construction.
+* You can pass to Ably a JWT of any structure that contains an Ably Token.
 
 In this tutorial, the first of these options will be used.
 
-In the following steps you will: 
+In the following steps you will:
 
-* Build a simple login form that will authenticate a client with Ably, using a JWT. 
-* Learn how to use the "jsonwebtoken":https://www.npmjs.com/package/jsonwebtoken npm library, which is an implementation of JWT. This library allows your auth server to conveniently create a JWT by specifying only certain service specific data in the payload and headers. 
-* Create a web app that provides an endpoint that returns a JWT that can be used to autheticate your Ably client.
+* Build a simple login form that will authenticate a client with Ably, using a JWT.
+* Learn how to use the "jsonwebtoken":https://www.npmjs.com/package/jsonwebtoken npm library, which is an implementation of JWT. This library allows your auth server to conveniently create a JWT by specifying only certain service specific data in the payload and headers.
+* Create a web app that provides an endpoint that returns a JWT that can be used to authenticate your Ably client.
 
 So, let's get started and see a typical client-server architecture using JWT authentication.
 
 h2(#live-demo). Ably JWT auth example - Live Demo
 
-This section contains a live demo of the project you will create in this tutorial. 
+This section contains a live demo of the project you will create in this tutorial.
 
-Enter any username and password into the following dialog and click the **Login** button:
 
-<section class="container">
-    <div class="login">
-        <form>
-            <input type="text" placeholder="Enter Username" name="username">
-            <br/>
-            <input type="password" placeholder="Password" name="password">
-            <br/>
-            <p class="submit">
-                <button type="submit" onclick="login(event)">Login</button>
-            </p>
-        </form>
-    </div>
-    <div>
-        <textarea id="result" rows="10" style="width: 60%; margin-top: 10px; font-family: courier, courier new; background-color: #333; color: orange" disabled></textarea>
-    </div>
+<section class="container live-demo-container">
+  <p>
+    Enter any username and password into the following
+    dialog and click the **Login** button:
+  </p>
+
+  <form>
+    <label for="username">Username</label>
+    <input type="text" placeholder="Enter Username" id="username" name="username">
+
+    <label for="username">Password</label>
+    <input type="password" placeholder="Password" id="password" name="password">
+
+    <button type="submit" onclick="login(event)">Login</button>
+  </form>
+
+  <div class="live-demo-response">
+     <textarea id="result" rows="10" disabled></textarea>
+  </div>
 </section>
 
 If the server returns a valid JWT the client is authenticated with Ably, and you see an alert box with the message: "Client successfully connected to Ably using JWT auth".
 
-The full code for this project can be found in its "Ably GitHub repository":https://github.com/ably/jwt-auth-node-tutorial.
+The full code for this project can be found in its "Ably GitHub repository":https://github.com/ably/tutorials/tree/jwt-authentication-nodejs.
 
 h2(#running-locally). Running the project locally
 
-In this section you'll learn how to clone the project code and run it locally. Alternatively, you can work through creating the project "step-by-step":#setup-ably-account. 
+In this section you'll learn how to clone the project code and run it locally. Alternatively, you can work through creating the project "step-by-step":#setup-ably-account.
 
 The project can be run locally using the following steps:
 
-1. Make sure that you have a "free Ably account":https://ably.com/sign-up. 
+1. Make sure that you have a "free Ably account":https://ably.com/sign-up.
 
 2. Make sure you have "Node.js":https://nodejs.org/en/ and "npm":https://www.npmjs.com/ installed on your system.
 
-3. Clone the project:
+3. Clone the Ably tutorials repository:
 
 ```[sh]
-git clone https://github.com/ably/jwt-auth-node-tutorial
+git clone git@github.com:ably/tutorials.git
 ```
 
-4. Change into the project directory @jwt-auth-node-tutorial@.
+4. Change to the project branch @jwt-authentication-nodejs@ where the source code resides.
+
+```[sh]
+git checkout jwt-authentication-nodejs
+```
 
 5. Copy @env.example@ to @.env@.
 
@@ -115,10 +123,10 @@ git clone https://github.com/ably/jwt-auth-node-tutorial
 You will see a dialog similar to the following displayed:
 
 <a href="/images/tutorials/jwt-auth/jwt-auth-output.png" target="_blank">
-    <img src="/images/tutorials/jwt-auth/jwt-auth-output.png" style="width: 80%" alt="JWT Demo">
+    <img src="/images/tutorials/jwt-auth/jwt-auth-output.png" style="width: 80%" alt="JWT Auth Demo">
 </a>
 
-9. Enter any username and password and click **Login**.
+10. Enter any username and password and click **Login**.
 
 An alert box is displayed containing the message "Client successfully connected to Ably using JWT auth".
 
@@ -126,7 +134,7 @@ An alert box is displayed containing the message "Client successfully connected
 
 h2(#step-2-creating-the-server). Step 2 - Creating the server
 
-This step shows you how to create the server code from scratch. If you get stuck at any point, you can always refer to the "complete code":https://github.com/ably/jwt-auth-node-tutorial.
+This step shows you how to create the server code from scratch. If you get stuck at any point, you can always refer to the "complete code":https://github.com/ably/tutorials/tree/jwt-authentication-nodejs.
 
 1. Make sure that you have "Node.js":https://nodejs.org/en/ and "npm":https://www.npmjs.com/ installed on your system.
 
@@ -136,135 +144,150 @@ This step shows you how to create the server code from scratch. If you get stuck
 npm install jsonwebtoken express
 ```
 
-3. Copy your API key to the clipboard, from your Ably Dashboard. It will be of the form @12AB3a.ab3GOm:c-B4Emryq9aFmOxP@.
+3. Copy your API key to the clipboard, from your Ably Dashboard.
+
+It will be of the form @<app ID>.<key ID>:<key secret>@.
+For example: @12AB3a.ab3GOm:c-B4Emryq9aFmOxP@.
 
 4. Create a @.env@ file with the following content:
 
-```
-API_KEY=your_api_key
+```[sh]
+ABLY_API_KEY=your_api_key
 ```
 
-5. Paste in your API key to replace @your_api_key@.
+Paste in your API key to replace @your_api_key@.
 
-6. Create a new file called @server.js@. Add the following code at the top of the file:
+5. Create a new file called @server.js@. Add the following code at the top of the file:
 
 ```[javascript]
-const jwt = require("jsonwebtoken") 
-require('dotenv').config()
+const jwt = require("jsonwebtoken");
+require('dotenv').config();
 ```
 
-This includes the JWT library you'll be using, and also loads the environment file containing your @API_KEY@.
+This includes the JWT library you'll be using, and also loads the environment file containing your @ABLY_API_KEY@.
 
-7. Add the following code:
+6. Add the following code:
 
 ```[javascript]
-const apiKey = process.env.API_KEY
-const keyParts = apiKey.split(':', 2);
-const keyName   = keyParts[0];
-const keySecret = keyParts[1];
-const ttlSeconds = 3600
+const apiKey = process.env.ABLY_API_KEY;
+const [ keyId, keySecret ] = apiKey.split(":");
+
+const expiresIn = 3600;
+const jwtOptions = { expiresIn, keyId };
 ```
 
-The Ably API key is split into two parts here: @keyName@, which is used for the @keyId@ in the JWT, and @keySecret@, which is used to sign the JWT.
+The Ably API key is split into two parts here: @keyId@, which is used for the @keyId@ in the JWT, and @keySecret@, which is used to sign the JWT.
 
-The @ttlSeconds@ constant is the duration (time-to-live) in seconds for which the JWT will be valid for. After this time the token has expired and can no longer be used for authentication, and a new one must be created.
+The @expiresIn@ constant is the number of seconds the JWT is valid for. After this time has elapsed, the token will expire and you must generate a new one to authenticate with.
 
 A JWT is typically made up of three different entities of data: a header, a payload and a signature. However, since you are using the "jsonwebtoken":https://www.npmjs.com/package/jsonwebtoken npm library, these details are abstracted away and you only need a key secret and any application-specific payload data. You can also add other options, such as if you need to use a non-default hashing algorithm.
 
-8. With Ably, you must send the time-to-live as well as the @keyid@ as part of the @jwtOptions@ parameter. You can optionally configure capabilities for the client using this token or a client ID, these will be part of the payload. Add the following code:
-
-```[javascript]
-const jwtPayload = {                                                                                                                                                                                                                                           
-    'x-ably-capability': JSON.stringify({ '*': ['publish', 'subscribe'] }),                                                                                                                                                                                    
-    'x-ably-clientId': 'OPTIONAL_CLIENT_ID'                                                                                                                                                                                                                    
-}                                                                                                                                                                                                                                                              
-                                                                                                                                                                                                                                                               
-const jwtOptions = {                                                                                                                                                                                                                                           
-    expiresIn: ttlSeconds,                                                                                                                                                                                                                                     
-    keyid: `${keyName}`                                                                                                                                                                                                                                         
-}      
-```
+The Ably platform expects you to send the time-to-live (@expiresIn@) and @keyId@ as part of the @jwtOptions@ parameter. You can optionally configure capabilities for the client using this token or a client ID, these will be part of the payload.
 
-9. To finish the web app you use "Express":https://www.npmjs.com/package/express to build a simple server to serve files on your localhost:
+7. In this step you will create a simple web server using the "Express web framework":https://www.npmjs.com/package/express to serve static files. In a later step you will also use this server to create an API route for clients to authenticate with.
 
 ```[javascript]
-const express = require('express'),
-    app = express();
+const express = require('express');
+const app = express();
+
 app.use('/', express.static(__dirname))
 ```
 
-The Express server uses a middleware to serve the content, and uses @express.static(__dirname)@ to specify that any HTML files in the root folder are served directly.
+The Express server uses middleware to serve the content, and uses @express.static(__dirname)@ to specify that any HTML files in the root folder are served directly.
+
+8. In a production application you would check that the user exists and is authorized to use your service before issuing a JWT with their user ID as the @clientId@. In this example you will just use the user ID they provide.
+
+In the @index.html@ file, instantiate the Ably client library with a "@ClientOptions@":/realtime-sdk#client-options object, passing in your authentication endpoint URL as the @authUrl@ property.
 
-10. Create the @/auth@ route in this server. This route is responsible for creating a JWT and sending this token back to the client:
+Append the user's input to this URL as a query string in the format: @/auth?clientId={username}:{password}@. You can access the @clientId@ parameter in the query string using the Express @Request@ object, as @req.query.clientId@
+
+This code is invoked when a client application makes a call to the @/auth@ route on your server.
 
 ```[javascript]
-app.get('/auth', (req, res) => {
-    console.log('Sucessfully connected to the server auth endpoint')
-    jwt.sign(jwtPayload, keySecret, jwtOptions, (err, tokenId) => {
-        console.log('JSON Web Token signed by auth server')
-        if (err) {
-            console.trace()
-            return
-        }
-        res.header('Cache-Control', 'private, no-cache, no-store, must-revalidate')
-        res.setHeader('Content-Type', 'application/json')
-        console.log('Sending signed JWT token back to client')
-        res.send(JSON.stringify(tokenId));
-    })
-                                                                                                                                                                                                                                                
-})
+app.get("/auth", (req, res) => {
+  console.log("Successfully connected to the server auth endpoint");
+
+  const randomId = Math.random().toString(16).slice(-8);
+  const clientId = req.query.clientId || randomId;
+
+  const jwtPayload = {
+    "x-ably-capability": capability,
+    "x-ably-clientId": clientId,
+  };
+
+  jwt.sign(jwtPayload, keySecret, jwtOptions, (err, tokenId) => {
+    console.log("JSON Web Token signed by auth server");
+
+    if (err) return console.trace();
+
+    res.header("Cache-Control", "private, no-cache, no-store, must-revalidate");
+    res.setHeader("Content-Type", "application/json");
+
+    console.log("Sending signed JWT token back to client", tokenId);
+    res.send(JSON.stringify(tokenId));
+  });
+});
 ```
 
-The previous code is invoked when a client application invokes the @/auth@ route on your auth server. 
+You have used the "jsonwebtoken":https://www.npmjs.com/package/jsonwebtoken npm library to sign a JWT using the Ably API key which you obtained from your dashboard. The callback function returns an error parameter and the @tokenId@. If there is an error, you log it to the console. If the operation is successful, you send the JWT back to the client. This JWT contains a token that the client can use to authenticate with:
 
-You have used the "jsonwebtoken":https://www.npmjs.com/package/jsonwebtoken npm library to sign a JWT using the Ably API key which you obtained from your dashboard. The callback function returns an error parameter and the @tokenId@. You then check for the error if any, otherwise send the JWT back to the client in order to confirm its authentication with Ably.
+```[json]
+{
+  "token": "xVLyHw.Dtxd9tuz....EXAMPLE",
+  "capability": "{\"*\":[\"*\"]}",
+  "clientId": "client@example.com",
+  "expires": 1449745287315,
+  "keyName": "xVLyHw.lCE5Tg",
+  "issued": 1449741687315
+}
+```
 
 Note that a cache-control has been added to the response header in order to prevent a cached token from being obtained. This makes sure you never obtain a token which has potentially expired.
 
-11. Set the web server to listen on a suitable port - 3000 is used in the following code example:
+9. Set the web server to listen on a suitable port - 3000 is used in the following code example:
 
 ```[javascript]
 app.listen(3000, function () {
-    console.log('Web server listening on port 3000');
+    console.log('Web server listening on port', 3000);
 });
 ```
 
-Complete code for this tutorial can be found in its "GitHub repository":https://github.com/ably/jwt-auth-node-tutorial. The server code you have just created can be found in @server.js@.
+Complete code for this tutorial can be found in its "GitHub repository":https://github.com/ably/tutorials/tree/jwt-authentication-nodejs. The server code you have just created can be found in @server.js@.
 
 h2(#step-3-creating-the-client). Step 3 - Creating the client
 
 You will now learn how to create a client with a simple login form. For the simplicity of this tutorial, your code will authenticate all users, irrespective of the data they enter in the username and the password fields. However, in a real deployment, your auth server would verify this data according to profile information stored in your user database and generate and return a JWT back to the client only if the verification was successful.
 
-1. A simple styling template is used to improve the design of the login form. Paste this "CSS code":https://raw.githubusercontent.com/ably/jwt-auth-node-tutorial/main/css/style.css into @css/style.css@.
+1. A simple styling template is used to improve the design of the login form.
+Paste this "CSS code":https://github.com/ably/tutorials/blob/jwt-authentication-nodejs/css/style.css into @css/style.css@.
 
 2. Now you will create the HTML file, @index.html@, for your front-end client. Embed the JavaScript logic directly into this file for simplicity. Add the following HTML to your @index.html@ file:
 
 ```[html]
 <html>
-<head>
-  <script src="https://cdn.ably.io/lib/ably.min-1.js" type="text/javascript"></script>
-  <link rel="stylesheet" href="css/style.css">
-</head>
-<body>
-  <section class="container">
-    <div class="login">
-      <h1>Ably JWT auth example</h1>
-      <form>
-        <input type="text" placeholder="Enter Username" name="username">
-        <br/>
-        <input type="password" placeholder="Password" name="password">
-        <br/>
-        <p class="submit">
+  <head>
+    <script src="https://cdn.ably.io/lib/ably.min-1.js" type="text/javascript"></script>
+    <link rel="stylesheet" href="css/style.css">
+  </head>
+
+  <body>
+    <section class="container">
+      <div class="login">
+        <h1>Ably JWT auth example</h1>
+        <form>
+          <label for="username">Username</label>
+          <input type="text" placeholder="Enter Username" id="username" />
+          <label for="password">Password</label>
+          <input type="password" placeholder="Password" id="password" />
           <button type="submit" onclick="login(event)">Login</button>
-        </p>
-      </form>
-    </div>
-  </section>
-</body>
+        </form>
+      </div>
+    </section>
+  </body>
 </html>
 ```
 
-As you can see, it's a simple HTML skeleton with a form containing two input fields, one for each username and password as well as a button for logging in. Ably is included through the CDN and the code also includes the stylesheet that you previously created. When the button is clicked, it invokes the login function that you'll now add using JavaScript.
+As you can see, it's a simple HTML skeleton with a form containing two input fields, one for each @username@ and @password@ as well as a button for logging in. Ably is included through the CDN and the code also includes the stylesheet that you previously created. When the button is clicked, it invokes the login function that you'll now add using JavaScript.
 
 The last part is to add the logic into this form. You'll instantiate Ably's Realtime client library and request a JWT. Please note that for simplicity, the code ignores the username and password credentials, which, in a practical deployment, would be verified by your auth server before signing a JWT and sending it back to the client.
 
@@ -273,31 +296,44 @@ The last part is to add the logic into this form. You'll instantiate Ably's Real
 ```[html]
 <script type="text/javascript">
 console.log('On login page now')
+
 function login(e) {
-    e.preventDefault();
-    console.log('Fetching JWT token from auth server')
-    const realtime = new Ably.Realtime({ authUrl: '/auth' });
-    realtime.connection.once('connected', function () {
-    console.log('Client connected to Ably using JWT')
-    alert("Client successfully connected to Ably using JWT auth")
-    })
-}
+  e.preventDefault();
+
+  const username = document.querySelector("#username").value;
+  const password = document.querySelector("#password").value;
+
+  if (!`${username}`.trim() || !`${password}`.trim()) {
+    return alert("Error! Require username and password");
+  }
+
+  // Send user details to the auth server
+  const authUrl = `/auth?clientId=${username}:${password}`;
+  const realtime = new Ably.Realtime({ authUrl });
+
+  console.log("Requesting Ably JWT token from auth server", username, password);
+
+  realtime.connection.once("connected", () => {
+    const { tokenDetails } = realtime.auth;
+    console.log("Client successfully connected to Ably using JWT auth", tokenDetails);
+    alert("Client successfully connected to Ably using JWT auth");
+  });
 </script>
 ```
 
-The code begins by instantiating Ably's Realtime client library, then you assign the path of auth server, @/auth@ to the @authUrl@ parameter. The @/auth@ path of on auth server is responsible for signing a JWT using the private API key and then returning back the @tokenId@, the JWT itself.
+The code begins by instantiating Ably's Realtime client library, then you assign the path of the auth server, @/auth@ to the @authUrl@ parameter. The @/auth@ path of the auth server is responsible for signing a JWT using the private API key and then returning back the @tokenId@, the JWT itself.
 
 With the returned JWT, the client automatically attempts to connect to Ably using it. If the client successfully authenticates with Ably, the code displays an alert to let the user know that the connection was successful.
 
-Complete code for this tutorial can be found in its "GitHub repository":https://github.com/ably/jwt-auth-node-tutorial.
+Complete code for this tutorial can be found in its "GitHub repository":https://github.com/ably/tutorials/tree/jwt-authentication-nodejs
 
 h2(#step-4-checking-the-output). Step 4 - Checking the output
 
-Now that you have all of your files in place, go ahead and test it out. 
+Now you are ready to test your application.
 
-1. Start your command line/terminal. 
+1. Start your command line/terminal.
 
-2. Change into your project directory. 
+2. Change into your project directory.
 
 3. Start your server by running:
 
@@ -305,11 +341,15 @@ Now that you have all of your files in place, go ahead and test it out.
 node server.js
 ```
 
-4. Navigate your browser to @http://localhost:3000@, since your Express server is listening on port 3000. 
+The server will output its log messages to your terminal.
+
+4. Visit @http://localhost:3000@ in your browser (because your Express server is listening on port 3000).
+
+In the browser you will see the login form.
 
-You will see the login form. Open the browser JavaScript console if you want to see the logged messages. 
+5. Open the browser developer console, to see messages logged by the client.
 
-5. Enter any data into the username and password fields and click **login**.
+6. Enter any values into the @username@ and @password@ fields and click **login**.
 
 You will see an alert with the message "Client successfully connected to Ably using JWT auth".
 
@@ -322,24 +362,31 @@ h2. Next steps
 5. Discover how "identities in tokens allow clients and servers to trust other clients' identities":/core-features/authentication#identified-clients validated and provided by your servers
 6. Learn more about other "Ably features":https://ably.com/platform by stepping through our other "Ably tutorials":https://ably.com/tutorials
 7. Gain a good technical "overview of how the Ably realtime platform works":https://ably.com/docs/key-concepts
-8. Obtain complete code for this tutorial from its "GitHub repository":https://github.com/ably/jwt-auth-node-tutorial.
+8. Obtain complete code for this tutorial from its "GitHub repository":https://github.com/ably/tutorials/tree/jwt-authentication-nodejs
 9. "Get in touch if you need help":https://ably.com/contact
-
+10. Read about third-party serverless integrations with "Netlify Identity for Ably authentication":https://ably.com/blog/netlify-indentity-jwt
 
 <!-- Code for live demo -->
 <script src="https://cdn.ably.io/lib/ably.min-1.js" crossorigin="anonymous"></script>
 <script type="text/javascript">
     /* Set up a Realtime client that authenticates with the local web server auth endpoint */
     var result = document.getElementById('result');
-    result.value += 'On login page now\n';
+    consoleLog('On login page now');
+
+    function consoleLog (text) {
+      result.value += `${text}\n`;
+      console.log(text);
+    }
+
     function login(e) {
         e.preventDefault();
-        result.value += 'Fetching JWT token from auth server\n';
+        consoleLog('Requesting JWT token from auth server');
+
         const realtime = new Ably.Realtime({ authUrl: 'https://ably.com/ably-auth/jwt-token/demos' });
         realtime.connection.once('connected', () => {
-            console.log('Client connected to Ably')
-            result.value += 'Client connected to Ably using JWT\n';
-            alert("Client successfully connected to Ably using JWT auth");
+            const message = "Client successfully connected to Ably using JWT auth";
+            consoleLog(message);
+            alert(message);
         })
     }
 </script>
