diff --git a/.github/pull_request_template.md b/.github/pull_request_template.md
new file mode 100644
index 0000000..d090ace
--- /dev/null
+++ b/.github/pull_request_template.md
@@ -0,0 +1,32 @@
+<!--- Provide a general summary of your changes in the Title above -->
+
+## Description / Motivation
+
+<!--- Describe your changes in detail -->
+<!--- Why is this change required? What problem does it solve? -->
+<!--- If it fixes an open issue, please link to the issue here. -->
+
+## How Has This Been Tested?
+
+<!--- Please describe in detail how you tested your changes. -->
+<!--- Include details of your testing environment, and the tests you ran to -->
+<!--- see how your change affects other areas of the code, etc. -->
+
+## Types of changes
+
+<!--- What types of changes does your code introduce? Put an `x` in all the boxes that apply: -->
+
+- [ ] Bug fix (non-breaking change which fixes an issue)
+- [ ] New feature (non-breaking change which adds functionality)
+- [ ] Breaking change (fix or feature that would cause existing functionality to change)
+- [ ] Documentation update (non-breaking change; modified files are limited to the `/docs` directory or other markdown files)
+
+## Checklist:
+
+<!--- Go over all the following points, and put an `x` in all the boxes that apply. -->
+<!--- If you're unsure about any of these, don't hesitate to ask. We're here to help! -->
+
+- [ ] I have read the Contributing guide.
+- [ ] My code/comments/docs fully adhere to the Code of Conduct.
+- [ ] My change is a code change.
+- [ ] My change is a documentation change and there are NO other updates required.
\ No newline at end of file
diff --git a/.npmrc b/.npmrc
new file mode 100644
index 0000000..4fd0219
--- /dev/null
+++ b/.npmrc
@@ -0,0 +1 @@
+engine-strict=true
\ No newline at end of file
diff --git a/README.md b/README.md
index 08bcc4e..251acc0 100644
--- a/README.md
+++ b/README.md
@@ -1,3 +1,6 @@
+![npm](https://img.shields.io/npm/dm/sitecore-cdp-serializer)
+[![npm version](https://badge.fury.io/js/sitecore-cdp-serializer.svg)](https://badge.fury.io/js/sitecore-cdp-serializer)
+
 ## Installation
 
 Sitecore CDP serializer requires [Node.js](https://nodejs.org) version 14 or above. To install, run the following commands from any directory in your terminal:
diff --git a/docs/commands/api.md b/docs/commands/api.md
index 0ce9166..0c96a52 100644
--- a/docs/commands/api.md
+++ b/docs/commands/api.md
@@ -4,9 +4,38 @@
 
 The API commands should never be used by a public application. Your Sitecore CDP/Personalize API Username and Password should never be send to anyone you don't trust. It's recommended that you create a Service API account in your Sitecore CDP/Personalize tenant so you can have more control over revoking access in the future.
 
-## Available Commands
+## Authentication Commands
 
-|   Command   | Description                                                     | Parameters                                     |
-| :---------: | :-------------------------------------------------------------- | :--------------------------------------------- |
-|    auth     | Required command to create access token for future CLI commands | -u, --username, -p, --password, -l, --location |
-| connections | Retrieve all connections from your connected tenant             | \<none>                                        |
+All authentication commands start with `auth`.
+
+| Subcommand | Description                                                     | Parameters                                                                              |
+| :--------: | :-------------------------------------------------------------- | :-------------------------------------------------------------------------------------- |
+|   login    | Required command to create access token for future CLI commands | -id, --clientId<br />-s, --clientSecret<br />-l, --location _optional_ (defaults to EU) |
+|   status   | View Authentication/Service Url information                     | \<none>                                                                                 |
+|   logout   | Logout of the API                                               | \<none>                                                                                 |
+
+### Example
+
+```bash
+npx sitecore-cdp-serializer auth login -id {Client Key} -s {API Token} -l {EU|US|APJ}
+```
+
+## Template Commands
+
+All template commands start with `templates`.
+
+| Subcommand | Description                                              | Parameters                                                  |
+| :--------: | :------------------------------------------------------- | :---------------------------------------------------------- |
+|    get     | Gets a list of Templates from the CDP/Personalize tenant | --friendlyId _optional_<br />--templateRef _optional_<br /> |
+|   create   | Creates a New Template based on a JSON object            | -t, --template                                              |
+|   update   | Updates an Existing Template based on a JSON object      | -t, --template                                              |
+
+### Example
+
+```bash
+npx sitecore-cdp-serializer templates get --friendlyId 'sitecore_test_template_1'
+```
+
+### Notes
+
+In order to run a templates command, you must have already run an `auth login` command to authenticate to the tenant you wish to access templates from.
diff --git a/docs/commands/deploy.md b/docs/commands/deploy.md
index e69de29..c90151f 100644
--- a/docs/commands/deploy.md
+++ b/docs/commands/deploy.md
@@ -0,0 +1,19 @@
+# Deploy Commands
+
+## Usage
+
+This command is useful for taking physical files and deploying them to a CDP, Personalize or CDP/Personalize tenant. Details of this command are below:
+
+| Command | Description                                         | Parameters                                            |
+| :-----: | :-------------------------------------------------- | :---------------------------------------------------- |
+| deploy  | Command to take physical files and deploy to Tenant | --artifactPath _optional_ (defaults to `./artifacts`) |
+
+### Example
+
+```bash
+npx sitecore-cdp-serializer deploy
+```
+
+### Notes
+
+In order to run a deploy command, you must have already run an `auth login` command to authenticate to the tenant you wish to deploy the artifacts out to.
diff --git a/package-lock.json b/package-lock.json
index 652dcb4..5db9414 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,6 +1,6 @@
 {
   "name": "sitecore-cdp-serializer",
-  "version": "0.1.2",
+  "version": "0.1.6",
   "lockfileVersion": 1,
   "requires": true,
   "dependencies": {
diff --git a/src/commands/api/Base.service.ts b/src/commands/api/Base.service.ts
new file mode 100644
index 0000000..837aaa2
--- /dev/null
+++ b/src/commands/api/Base.service.ts
@@ -0,0 +1,61 @@
+/**
+ * Base service for all API calls
+ */
+
+ import Configstore from "configstore";
+ import { AuthToken } from './auth/Auth.interface.js';
+ import fetch from 'node-fetch';
+ 
+ const BaseService = (config: Configstore) => {
+     const serviceUrl = config.get('serviceUrl');
+     const credentials: AuthToken = config.get('credentials');
+ 
+     const Fetch = async(method: string, path: string, body: object | null | undefined) => {
+         if (!serviceUrl) {
+             throw 'Service URL not set, re-run auth command';
+         }
+       
+         if (!credentials) {
+             throw 'You must run the auth command first to initialize the CLI';
+         }
+
+         let data = body !== null && body !== undefined
+            ? JSON.stringify(body)
+            : null;
+ 
+         return await fetch(`https://${serviceUrl}/${path}`, {
+             method,
+             body: data,
+             headers: {
+               Authorization: `Bearer ${credentials.access_token}`,
+               'Content-Type': 'application/json',
+             },
+         });
+     }
+ 
+     const Get = async(path: string) => {
+         return await Fetch("get", path, null);
+     }
+ 
+     const Post = async(path: string, body: object | null | undefined) => {
+         return await Fetch("post", path, body);
+     }
+ 
+     const Put = async(path: string, body: object | null | undefined) => {
+         return await Fetch("put", path, body);
+     }
+ 
+     const Delete = async(path: string, body: object | null | undefined) => {
+         return await Fetch("delete", path, body);
+     }
+ 
+     return {
+         Fetch,
+         Get,
+         Post,
+         Put,
+         Delete,
+     };
+ }
+ 
+ export { BaseService };
\ No newline at end of file
diff --git a/src/commands/api/auth/Auth.service.ts b/src/commands/api/auth/Auth.service.ts
index ddac94d..a796671 100644
--- a/src/commands/api/auth/Auth.service.ts
+++ b/src/commands/api/auth/Auth.service.ts
@@ -3,7 +3,12 @@ import { AuthToken } from './Auth.interface.js';
 import fetch, { Response } from 'node-fetch';
 import chalk from 'chalk';
 import { Command } from 'commander';
-import { initServiceLocation, log, logline } from '../../../utils/index.js';
+import {
+  initServiceLocation,
+  logline,
+  logSuccess,
+  logError,
+} from '../../../utils/index.js';
 
 let globalConfig: Configstore;
 
@@ -35,10 +40,10 @@ const Authenticate = async (clientId: string, clientSecret: string) => {
     if (authToken) {
       globalConfig.set('credentials', authToken);
 
-      logline(chalk.green('Token Stored for future uses'));
+      logSuccess('Token Stored for future uses');
     }
   } else {
-    logline(chalk.red('Authentication Failed'));
+    logError('Authentication Failed');
   }
 };
 
diff --git a/src/commands/api/templates/Template.service.ts b/src/commands/api/templates/Template.service.ts
index b25e551..c54e1ef 100644
--- a/src/commands/api/templates/Template.service.ts
+++ b/src/commands/api/templates/Template.service.ts
@@ -1,143 +1,92 @@
 import Configstore from 'configstore';
-import fetch, { Response } from 'node-fetch';
-import chalk from 'chalk';
-import { AuthToken } from '../auth/Auth.interface.js';
+import { Response } from 'node-fetch';
 import { Command } from 'commander';
 import { Template } from './Template.interface.js';
-import { logline } from '../../../utils/index.js';
+import {
+  logline,
+  logSuccess,
+  logError,
+  logResponse,
+} from '../../../utils/index.js';
+import { BaseService } from '../Base.service.js'
 
 const TemplateService = (config: Configstore) => {
-  const serviceUrl = config.get('serviceUrl');
-  const credentials: AuthToken = config.get('credentials');
-
+  const baseService = BaseService(config);
+  
   const GetAllTemplates = async (templateType: string) => {
-    if (!serviceUrl) {
-      logline(chalk.red('Service URL not set, re-run auth command'));
-      return;
-    }
-
-    if (!credentials) {
-      logline(chalk.red('You must run the auth command first to initialize the CLI'));
-      return;
-    }
-
-    let servicePath = `https://${serviceUrl}/v3/templates`;
-
-    const response: Response = await fetch(servicePath, {
-      method: 'get',
-      body: null,
-      headers: {
-        Authorization: `Bearer ${credentials.access_token}`,
-      },
-    });
-
-    if (response.ok) {
-      logline(chalk.green('success'));
-      let templates: Template[] = (await response.json()) as Template[];
-
-      return templates;
-    } else {
-      console.log(chalk.red('Failed to retrieve templates'));
+    try {
+      const response: Response = await baseService.Get('v3/templates');
+  
+      if (response.ok) {
+        logSuccess('success');
+        let templates: Template[] = (await response.json()) as Template[];
+  
+        return templates;
+      } else {
+        logResponse(response, 'Failed to retrieve templates');
+      }
+    } catch (ex) {
+      logError(ex);
     }
   };
 
   const GetByFriendlyId = async (friendlyId: string): Promise<Template | null> => {
-    if (!serviceUrl) {
-      logline(chalk.red('Service URL not set, re-run auth command'));
-      return null;
-    }
-
-    if (!credentials) {
-      logline(chalk.red('You must run the auth command first to initialize the CLI'));
-      return null;
-    }
-
-    let servicePath = `https://${serviceUrl}/v3/templates/${friendlyId}`;
-
-    const response: Response = await fetch(servicePath, {
-      method: 'get',
-      body: null,
-      headers: {
-        Authorization: `Bearer ${credentials.access_token}`,
-      },
-    });
-
-    if (response.ok) {
-      const result: Template = (await response.json()) as Template;
+    try {
+      const response: Response = await baseService.Get(`v3/templates/${friendlyId}`);
 
-      logline(chalk.green('Template retrieved successfully'));
+      if (response.ok) {
+        const result: Template = (await response.json()) as Template;
+        logSuccess('Template retrieved successfully');
 
-      return result;
-    } else {
-      logline(chalk.red('Failed to retrieve template'));
-      return null;
+        return result;
+      } else {
+        logResponse(response, 'Failed to retrieve template');
+        return null;
+      }
+    } catch (ex) {
+      logError(ex);
     }
+
+    return null;
   };
 
   const CreateTemplate = async (template: Template): Promise<Template | null> => {
-    if (!serviceUrl) {
-      logline(chalk.red('Service URL not set, re-run auth command'));
-      return null;
-    }
-
-    if (!credentials) {
-      logline(chalk.red('You must run the auth command first to initialize the CLI'));
-      return null;
-    }
-
-    let servicePath = `https://${serviceUrl}/v3/templates`;
 
-    const response: Response = await fetch(servicePath, {
-      method: 'post',
-      body: JSON.stringify(template),
-      headers: {
-        Authorization: `Bearer ${credentials.access_token}`,
-        'Content-Type': 'application/json',
-      },
-    });
+    try {
+      const response: Response = await baseService.Post('v3/templates', template);
 
-    if (response.ok) {
-      const result: Template = (await response.json()) as Template;
+      if (response.ok) {
+        const result: Template = (await response.json()) as Template;
 
-      return result;
-    } else {
-      logline(chalk.red('Failed to create template'));
-      logline(JSON.stringify(await response.json()));
-      return null;
+        return result;
+      } else {
+        logResponse(response, 'Failed to create template');
+        return null;
+      }
+    } catch (ex) {
+      logError(ex);
     }
+    
+    return null;
   };
 
   const UpdateTemplate = async (template: Template): Promise<Template | null> => {
-    if (!serviceUrl) {
-      logline(chalk.red('Service URL not set, re-run auth command'));
-      return null;
-    }
-
-    if (!credentials) {
-      logline(chalk.red('You must run the auth command first to initialize the CLI'));
-      return null;
-    }
-
-    let servicePath = `https://${serviceUrl}/v3/templates/${template.ref}`;
+    try {
+      const response: Response = await baseService.Put(`v3/templates/${template.ref}`, template);
 
-    const response: Response = await fetch(servicePath, {
-      method: 'put',
-      body: JSON.stringify(template),
-      headers: {
-        Authorization: `Bearer ${credentials.access_token}`,
-        'Content-Type': 'application/json',
-      },
-    });
-
-    if (response.ok) {
-      const result: Template = (await response.json()) as Template;
+      if (response.ok) {
+        const result: Template = (await response.json()) as Template;
 
-      return result;
-    } else {
-      logline(chalk.red('Failed to update template'));
-      logline(JSON.stringify(await response.json()));
-      return null;
+        return result;
+      } else {
+        logResponse(response, 'Failed to update template');
+        return null;
+      }
+    } catch (ex) {
+      logError(ex);
     }
+
+    return null;
   };
 
   return {
diff --git a/src/commands/api/templates/TemplateType.ts b/src/commands/api/templates/TemplateType.ts
new file mode 100644
index 0000000..69faec2
--- /dev/null
+++ b/src/commands/api/templates/TemplateType.ts
@@ -0,0 +1,5 @@
+export enum TemplateType {
+    Decision = 'DECISION',
+    Web = 'WEB',
+    Audience = 'AUDIENCE'
+}
\ No newline at end of file
diff --git a/src/commands/deploy/deploy.ts b/src/commands/deploy/deploy.ts
index e2fc5f2..293121b 100644
--- a/src/commands/deploy/deploy.ts
+++ b/src/commands/deploy/deploy.ts
@@ -16,6 +16,7 @@ const deploy = async ({ artifactPath = './artifacts' }: DeployProps) => {
 
   if (!(await checkFolder(artifactDirectory))) {
     logline(chalk.red(`Artifacts folder doesn't exist`));
+    return;
   }
 
   await deployTemplates(artifactDirectory, globalConfig);
@@ -26,20 +27,12 @@ const initDeployCommands = (program: Command, config: Configstore) => {
 
   const deployCommands = program
     .command('deploy')
-    .option(
-      '--artifactPath <artifactPath>',
-      'Path to your CDP/Personalize Artifacts to deploy',
-      './artifacts'
-    )
+    .option('--artifactPath <artifactPath>', 'Path to your CDP/Personalize Artifacts to deploy', './artifacts')
     .description('Will consume artifacts and deploy them to CDP/Personalize tenant')
     .action(async (options) => {
       await deploy({ artifactPath: options.artifactPath });
     });
 
-  //deployCommands.command('templates').action(async (options) => {
-
-  //});
-
   return deployCommands;
 };
 
diff --git a/src/utils/command-helpers.ts b/src/utils/command-helpers.ts
index e99441f..c83729b 100644
--- a/src/utils/command-helpers.ts
+++ b/src/utils/command-helpers.ts
@@ -1,3 +1,6 @@
+import chalk from 'chalk';
+import { Response } from 'node-fetch';
+
 const logJson = (message: any = '') => {
   process.stdout.write(JSON.stringify(message, null, 2));
 };
@@ -10,4 +13,29 @@ const logline = (message: any = '', ...args: any[]) => {
   process.stdout.write(message + '\n', ...args);
 };
 
-export { logJson, log, logline };
+const logSuccess = (message: any = '') => {
+  logline(chalk.green(message));
+}
+
+const logError = (message: any = '') => {
+  logline(chalk.red(message));
+}
+
+const logResponse = async (response: Response, message: any) => {
+  if (message) {
+    logline(response.ok
+      ? chalk.green(message)
+      : chalk.red(message)
+    );
+  }
+  logline(JSON.stringify(await response.json()));
+};
+
+export {
+  logJson,
+  log,
+  logline,
+  logSuccess,
+  logError,
+  logResponse
+};
diff --git a/src/utils/deploy/helpers.ts b/src/utils/deploy/helpers.ts
index ba5b66e..6d2327d 100644
--- a/src/utils/deploy/helpers.ts
+++ b/src/utils/deploy/helpers.ts
@@ -3,14 +3,12 @@ import fs from 'fs';
 import { logline } from '../command-helpers.js';
 
 const checkFolder = async (folder: string): Promise<boolean> => {
-  fs.access(folder, (err) => {
-    if (err) {
-      logline(chalk.red(`Directory does not exist`));
-      return false;
-    }
-  });
-
-  return true;
+  try {
+    await fs.promises.access(folder);
+    return true
+  } catch (ex) {}
+
+  return false;
 };
 
 const getFolders = async (folder: string): Promise<string[]> => {
diff --git a/src/utils/deploy/templates.ts b/src/utils/deploy/templates.ts
index 837bef7..00abbc8 100644
--- a/src/utils/deploy/templates.ts
+++ b/src/utils/deploy/templates.ts
@@ -4,6 +4,7 @@ import { logline } from '../command-helpers.js';
 import { checkFolder, getFolderFiles, getFolders } from './helpers.js';
 import fs from 'fs';
 import { Template, TemplateElement } from '../../commands/api/templates/Template.interface.js';
+import { TemplateType } from '../../commands/api/templates/TemplateType.js'
 import Configstore from 'configstore';
 import { TemplateService } from '../../commands/api/templates/Template.service.js';
 import yaml from 'js-yaml';
@@ -27,8 +28,9 @@ const deployTemplates = async (artifactDirectory: string, config: Configstore) =
     return;
   }
 
-  await deployTemplateTypes(artifactDirectory, 'DECISION', config);
-  await deployTemplateTypes(artifactDirectory, 'WEB', config);
+  await deployTemplateTypes(artifactDirectory, TemplateType.Decision, config);
+  await deployTemplateTypes(artifactDirectory, TemplateType.Web, config);
+  await deployTemplateTypes(artifactDirectory, TemplateType.Audience, config);
 
   logline(chalk.greenBright(`Finished deploying templates`));
 };
@@ -42,13 +44,13 @@ const deployTemplateTypes = async (
   const templateFolder = path.join(artifactDirectory, 'templates', templateType.toLowerCase());
   const clientKey: string = config.get('clientKey');
 
-  logline(chalk.greenBright(`Starting to deploy ${templateType} templates`));
-
   if (!(await checkFolder(templateFolder))) {
     logline(chalk.red(`${templateType} templates folder doesn't exist - will not deploy`));
     return;
   }
 
+  logline(chalk.greenBright(`Starting to deploy ${templateType} templates`));
+
   const templatesToRun: string[] = await getFolders(templateFolder);
 
   if (templatesToRun.length === 0) {
@@ -187,9 +189,10 @@ const deployIndividualTemplates = async (
     } else {
       logline(chalk.greenBright(`Template ${template.friendlyId} does not exist in the tenant - will create`));
 
-      template.status = 'PUBLISHED';
+      // template.status = 'PUBLISHED';
 
-      result = templateService.CreateTemplate(template);
+      // logline(JSON.stringify(template));
+      result = await templateService.CreateTemplate(template);
 
       if (result != null) {
         logline(chalk.greenBright(`Template ${template.friendlyId} successfully deployed`));