diff --git a/.assets/oauth.png b/.assets/oauth.png
new file mode 100644
index 0000000..646eaa0
Binary files /dev/null and b/.assets/oauth.png differ
diff --git a/.assets/welcome-message.png b/.assets/welcome-message.png
new file mode 100644
index 0000000..b886034
Binary files /dev/null and b/.assets/welcome-message.png differ
diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml
index 2a65bce..5023e50 100644
--- a/.github/workflows/main.yml
+++ b/.github/workflows/main.yml
@@ -34,7 +34,11 @@ jobs:
           && sudo apt-get install -y git
 
       # Checks-out your repository under $GITHUB_WORKSPACE, so your job can access it
-      - uses: actions/checkout@v2
+      
+      - uses: actions/checkout@v3
+        # fetch all history for all branches and tags, so that our `make` targets can get tags
+        with:
+          fetch-depth: 0
 
       - name: Set up Docker Buildx
         uses: docker/setup-buildx-action@v1
diff --git a/.github/workflows/pr.yml b/.github/workflows/pr.yml
index b527904..ca66f02 100644
--- a/.github/workflows/pr.yml
+++ b/.github/workflows/pr.yml
@@ -11,6 +11,8 @@ jobs:
     runs-on: ubuntu-latest
 
     steps:
-    - uses: actions/checkout@v2
-    - name: Build the Docker image
-      run: docker build . --file Dockerfile
+      - uses: actions/checkout@v3
+        with:
+          fetch-depth: 0
+      - name: Build the Docker image
+        run: docker build . --file Dockerfile
diff --git a/.gitignore b/.gitignore
index f2e14de..b2e97c3 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,4 +1,5 @@
 **/*.swp
 whodis.exe
+whodis
 .env
-servers
\ No newline at end of file
+servers
diff --git a/Dockerfile b/Dockerfile
index 3397637..f102b68 100644
--- a/Dockerfile
+++ b/Dockerfile
@@ -13,6 +13,9 @@ RUN go mod download
 
 COPY . .
 
+# Get latest tag
+RUN git describe --abbrev=0 > /version
+
 RUN go install github.com/UCCNetsoc/whodis/cmd/whodis
 
 CMD [ "go", "run", "*.go" ]
@@ -22,5 +25,6 @@ FROM alpine
 WORKDIR /bin
 
 COPY --from=dev /go/bin/whodis ./whodis
+COPY --from=dev /version /version
 
-CMD ["sh", "-c", "whodis -p"]
\ No newline at end of file
+CMD ["sh", "-c", "export BOT_VERSION=$(cat /version) && whodis -p"]
diff --git a/README.md b/README.md
index 3023f84..6419444 100644
--- a/README.md
+++ b/README.md
@@ -1,3 +1,68 @@
 # Whodis
 
-Discord bot & API to both authenticate and authorize discord members
+[![CI](https://github.com/UCCNetsoc/whodis/actions/workflows/main.yml/badge.svg)](https://github.com/UCCNetsoc/whodis/actions/workflows/main.yml) [![!Whodis Bot Invite link](https://img.shields.io/badge/Whodis-Bot%20Invite-9cf)](https://google.com)
+
+A discord bot and API to authenticate Discord members as being UCC students.
+
+## How it works
+
+When a new user joins your _registration channel_, they will see a message from Whodis, welcoming them to the server, and prompts them to click a button to register.
+
+<img src=".assets/welcome-message.png" alt="Welcome Message" height="150px" />
+
+When they click the button, Whodis takes note of their Discord ID, and sends a message only they can see with a button, which will direct them to login page with their UCC Umail account as an option. After successfully choosing their Umail account, they will come to a landing page informing them of their successful authentication.
+
+<img src="./.assets/oauth.png" height="350px" />
+
+When they go back to Discord, they will have gained a role(s), giving them permission to see more of the server.
+
+---
+
+## How Do I Use this Bot on my Server?
+
+A server member with Admin privileges can add the bot to their server by doing the following:
+
+1. Invite Whodis to your Discord server.
+2. Create the `@Member` role. Make this role able to access normal channels in your server.
+3. Create a `#registration` and `#registration-help` channel. Make these channels incassessible by `@Member`, but allow moderators and `@everyone`. This way, only newly-joined users and moderators can see these channels.
+
+> Note this will make it so all existing non-moderator members of your Discord server will either have to be manually given the `@Member` role, or authenticate with Whodis.
+
+4. In the `#registration` channel, run the `/setup` command, and give the parameters you require.
+
+| Parameter           | Required  | Description                                                             |
+| ------------------- | --------- | ------------------------------------------------------------------------|
+| `announce-channel`  | ✅        | The channel where new users are announc ed                              |
+| `logging-channel`   | ✅        | The channel where logs are sent                                         |
+| `additional-role-1` | ❌        | An additional role that can be given to new members, e.g. `@22/23`      |
+| `additional-role-2` | ❌        | Another additional role that can be given to new members, e.g. `@newbies` |
+
+---
+
+## Need to use a different Mail Domain or want to self-host this Bot?
+
+If you need to use a mail domain that isn't `umail.ucc.ie` you can fork this repo and use Docker to run the bot, providing a specific mail domain to use through environment variables.
+
+To see all necessary environment variables, check [defaults.go](./config/defaults.go) (Environment variables will be in the form of UPPER_CASE).
+
+---
+
+## Privacy Concerns
+
+Whodis and as such, Netsoc do not collect any personal information, as the bot and API are stateless. When a user clicks the first button, the following data is encoded into a new button:
+
+- The User's Discord ID
+- The Server's registered role, and an optional second role to give to newly-registered users.
+- The server's Guild ID
+- The server's welcome message Channel ID
+- The server's moderator logging Channel ID
+
+This data does not get stored on any database, and is encrypted on the backend, to stop a user tampering-with and gaining access to a role not intended for them to have.
+
+**_Whodis does not store any Users' Discord ID or Umail address_**
+
+---
+
+## Help
+
+If you have any questions or need help, please contact the Netsoc SysAdmins on [discord](https://discord.netsoc.co/), by email at [netsoc@uccsocieties.ie](mailto:netsoc@uccsocieties.ie), or [create an issue](https://github.com/UCCNetsoc/whodis/issues/new).
diff --git a/cmd/whodis/main.go b/cmd/whodis/main.go
index be99bbe..1a01e2f 100644
--- a/cmd/whodis/main.go
+++ b/cmd/whodis/main.go
@@ -35,9 +35,11 @@ func main() {
 		log.WithError(err)
 		return
 	}
+
 	go api.InitAPI(s)
+
 	s.AddHandler(func(s *discordgo.Session, r *discordgo.Ready) {
-		log.Info("Bot is has registered handlers")
+		log.Info("Bot has registered handlers")
 	})
 	s.Open()
 	commands.RegisterSlashCommands(s)
diff --git a/docker-compose.yml b/docker-compose.yml
new file mode 100644
index 0000000..85090cc
--- /dev/null
+++ b/docker-compose.yml
@@ -0,0 +1,17 @@
+version: '3.7'
+
+services:
+  bot:
+    build: .
+    container_name: whodis_local
+    ports:
+      - "8080:8080"
+    environment:
+      DISCORD_TOKEN: ${DISCORD_TOKEN}
+      DISCORD_APP_ID: ${DISCORD_APP_ID}
+      DISCORD_BOT_INVITE: ${DISCORD_BOT_INVITE}
+      API_URL: ${API_URL}
+      API_PORT: '8080'
+      API_SECRET: ${API_SECRET}
+      OAUTH_GOOGLE_ID: ${OAUTH_GOOGLE_ID}
+      OAUTH_GOOGLE_SECRET: ${OAUTH_GOOGLE_SECRET}
diff --git a/internal/api/assets/result.html b/internal/api/assets/result.html
index 8214b04..28d1d8b 100644
--- a/internal/api/assets/result.html
+++ b/internal/api/assets/result.html
@@ -15,7 +15,9 @@
             font-size: 14px;
             font-weight: 400;
             font-family: Roboto, sans-serif !important;
-            color: #fff
+            color: #fff;
+            min-height: 100vh;
+            position: relative;
         }
 
         #header {
@@ -39,12 +41,12 @@
         #content-body {
             padding-top: 16px;
             border-top: 1px solid #333;
-            color: gray;
+            color: #b9b9b9;
             border-bottom: 1px solid #333
         }
 
         p {
-            max-width: 380px;
+            max-width: 400px;
             margin: 0 auto;
             padding: 16px;
         }
@@ -87,6 +89,15 @@
         a {
             color: #fff
         }
+
+        footer {
+            width: 100%;
+            position: absolute;
+            left: 0;
+            right: 0;
+            bottom: 0;
+            padding-bottom: 16px;
+        }
     </style>
     <script type="text/javascript">
         function stopReload(){
@@ -109,20 +120,16 @@
             <h1>Whodis Authentication Service</h1>
         </div>
         <div id="content-body">
-            <h2>{{.Type}}</h2>
+            <h2 id="status"><span>Success</span></h2>
             <p style="color: white">{{.Message}}</p>
-            <p>Contact Netsoc SysAdmins on our <a href='http://discord.netsoc.co'>Discord</a> if you encounter any issues
+            <p>Contact Netsoc SysAdmins on our <a href='http://discord.netsoc.co'>Discord</a>, or <a href="https://github.com/UCCNetsoc/whodis/issues/new">create an issue</a> if you encounter any issues
         </div>
-        <div style="
-      margin: 0 auto;
-      text-align: center;
-      padding-top: 16px;
-      font-size: 11px;
-      color: gray;
-    ">
+        <footer>
             <a target="_blank" href="https://discord.netsoc.co">Discord</a>
             <span> • </span>
-            <a target="_blank" href="https://wiki.netsoc.co/en/services/terms-of-service">Terms of Service</a>
+            <a target="_blank" href="https://github.com/UCCNetsoc/whodis">Source Code</a>
+            <span> • </span>
+            <a target="_blank" href="https://github.com/UCCNetsoc/whodis/blob/master/README.md#privacy-concerns">Privacy Notice</a>
         </div>
 </body>
 </html>
\ No newline at end of file
diff --git a/internal/api/response.go b/internal/api/response.go
index 93b09d5..93d8f48 100644
--- a/internal/api/response.go
+++ b/internal/api/response.go
@@ -1,6 +1,7 @@
 package api
 
 import (
+	"html/template"
 	"net/http"
 
 	"github.com/Strum355/log"
@@ -8,22 +9,27 @@ import (
 
 type Resp struct {
 	Code    int                    `json:"code"`
-	Type    string                 `json:"type"`
+	Type    template.HTML          `json:"type"`
 	Message string                 `json:"message"`
 	Fields  map[string]interface{} `json:"fields,omitempty"`
 }
 
+const (
+	successType = `<span style='color: limegreen'>Success</span>`
+	errorType   = `<span style='color: red'>Error</span>`
+)
+
 func AccessErrorResponse(status int, message string, respErr error) *Resp {
 	if respErr != nil {
 		log.WithError(respErr).Error(message)
 	} else {
 		log.Error(message)
 	}
-	return &Resp{Code: status, Type: "Error", Message: message}
+	return &Resp{Code: status, Type: errorType, Message: message}
 }
 
 func AccessSuccessResponse(message string, uid string, gid string) *Resp {
 	fields := map[string]interface{}{"user": uid, "guild": gid}
 	log.WithFields(fields).Info(message)
-	return &Resp{Code: http.StatusOK, Type: "Success", Message: message, Fields: fields}
+	return &Resp{Code: http.StatusOK, Type: successType, Message: message, Fields: fields}
 }
diff --git a/internal/api/verify.go b/internal/api/verify.go
index 8791cba..090e8c5 100644
--- a/internal/api/verify.go
+++ b/internal/api/verify.go
@@ -3,17 +3,19 @@ package api
 import (
 	"embed"
 	"errors"
+	"fmt"
 	"html/template"
 	"net/http"
 	"strings"
 
+	"github.com/Strum355/log"
 	"github.com/UCCNetsoc/whodis/pkg/utils"
 	"github.com/bwmarrin/discordgo"
 	"github.com/gin-gonic/gin"
 	"github.com/spf13/viper"
 )
 
-const success = "You have successfully registered for the discord server."
+const success = "You have successfully registered for the discord server, you can return to discord, where you have elevated permissions."
 
 //go:embed assets/*
 var pageData embed.FS
@@ -23,27 +25,52 @@ var resultTemplate = template.Must(template.ParseFS(pageData, "assets/result.htm
 // createVerifyHandler creates handles the /verify callback endpoint.
 func createVerifyHandler(s *discordgo.Session) gin.HandlerFunc {
 	return func(c *gin.Context) {
-		uid, gid, cid, rid, err := dataFromState(c.Query("state"))
+		uid, gid, announce_cid, logging_cid, rid, err := dataFromState(c.Query("state"))
 		if err != nil {
-			resultTemplate.Execute(c.Writer, AccessErrorResponse(http.StatusInternalServerError, "Error decoding state from URL.", err))
+			resultTemplate.Execute(c.Writer,
+				AccessErrorResponse(http.StatusInternalServerError, "Error decoding state from URL.", err),
+			)
+			log.WithError(err).Error("Error decoding state from URL.")
+			utils.SendLogMessage(s, logging_cid, "Failed to verify integrity of unique link for user. If issues persist, create an issue at https://github.com/UCCNetsoc/whodis")
 			return
 		}
+
+		user, err := s.User(uid)
+		if err != nil {
+			resultTemplate.Execute(c.Writer, AccessErrorResponse(http.StatusInternalServerError, "Error getting user", err))
+			utils.SendLogMessage(s, logging_cid, "Failed to get user `"+uid+"` from Discord API to add roles.")
+			return
+		}
+
 		if err := addRoles(s, gid, uid, rid); err != nil {
-			resultTemplate.Execute(c.Writer, AccessErrorResponse(http.StatusInternalServerError, "Error adding roles to Discord user.", err))
+			resultTemplate.Execute(c.Writer,
+				AccessErrorResponse(http.StatusInternalServerError, "Error adding roles to Discord user.", err),
+			)
+
+			log.Error("Error adding roles to Discord user: " + user.Username + "#" + user.Discriminator + " on guild: " + gid)
+
+			utils.SendLogMessage(s, logging_cid,
+				fmt.Sprintf("Failed to add roles to user %s. Ensure that Whodis has permission to manage user roles.", user.Username+"#"+user.Discriminator),
+			)
 			return
 		}
 
 		// Get welcome channel.
-		channelID, ok := viper.GetStringMapString("discord.guild.members.channel")[gid]
+		announceChannelID, ok := viper.GetStringMapString("discord.guild.members.channel")[gid]
 		if !ok {
-			if cid != "" {
-				channelID = cid
-			} else if channelID, err = getDefaultChannel(s, gid); err != nil {
-				resultTemplate.Execute(c.Writer, AccessErrorResponse(http.StatusInternalServerError, "Error querying channels for welcome message.", err))
+			if announce_cid != "" {
+				announceChannelID = announce_cid
+			} else if announceChannelID, err = getDefaultChannel(s, gid); err != nil {
+				resultTemplate.Execute(c.Writer,
+					AccessErrorResponse(http.StatusInternalServerError, "Error querying channels for welcome message.", err),
+				)
+				utils.SendLogMessage(s, logging_cid,
+					"Failed to get announce channel, ensure the channel is a text channel and try using the **/setup** command again.",
+				)
 				return
 			}
 		}
-		if channelID == "" {
+		if announceChannelID == "" {
 			resultTemplate.Execute(c.Writer, *AccessSuccessResponse(success, uid, gid))
 			return
 		}
@@ -55,16 +82,27 @@ func createVerifyHandler(s *discordgo.Session) gin.HandlerFunc {
 		}
 
 		// Welcome user in channel.
-		user, err := s.User(uid)
-		if err != nil {
-			resultTemplate.Execute(c.Writer, AccessErrorResponse(http.StatusInternalServerError, "Error getting user", err))
-			return
-		}
-		if _, err := s.ChannelMessageSend(channelID, "Welcome **"+user.Mention()+"**! "+welcomeMessage); err != nil {
-			resultTemplate.Execute(c.Writer, AccessErrorResponse(http.StatusInternalServerError, "Error sending message to welcome channel", err))
+		if _, err := s.ChannelMessageSend(announceChannelID, "Welcome "+user.Mention()+"! "+welcomeMessage); err != nil {
+			resultTemplate.Execute(c.Writer,
+				AccessErrorResponse(http.StatusInternalServerError, "Error sending message to welcome channel", err),
+			)
+			utils.SendLogMessage(s, logging_cid, "Failed to send message to announce channel, ensure permissions allow the bot to do so, or try the **/setup** command again.")
 			return
 		}
 		resultTemplate.Execute(c.Writer, *AccessSuccessResponse(success, uid, gid))
+		log.Info("Successfully verified user: " + user.Username + "#" + user.Discriminator + " on guild: " + gid)
+		roles := []string{"**" + viper.GetString("discord.member.role") + "**"}
+		for _, role_id := range rid {
+			role, err := s.State.Role(gid, role_id)
+			if err != nil {
+				utils.SendLogMessage(s, logging_cid, "Failed to get role `"+role_id+"` from Discord API to add to user.")
+				continue
+			}
+			roles = append(roles, "**"+role.Name+"**")
+		}
+		utils.SendLogMessage(s, logging_cid,
+			fmt.Sprintf("User %s successfully verified, roles added: %s", user.Mention(), strings.Join(roles, ", ")),
+		)
 	}
 }
 
@@ -103,7 +141,7 @@ func addRoles(s *discordgo.Session, gid, uid string, rid []string) error {
 	return nil
 }
 
-func dataFromState(state string) (uid string, gid string, cid string, rid []string, err error) {
+func dataFromState(state string) (uid string, gid string, announce_cid string, logging_cid string, rid []string, err error) {
 	if len(state) == 0 {
 		err = errors.New("no state found")
 		return
@@ -112,17 +150,19 @@ func dataFromState(state string) (uid string, gid string, cid string, rid []stri
 	if decodedDigest, err = utils.Decrypt(state, []byte(viper.GetString("api.secret"))); err != nil {
 		return
 	}
+	log.Info("Decoded digest: " + decodedDigest)
 	encodedData := strings.Split(decodedDigest, ".")
-	encodedUID, encodedGID := encodedData[0], encodedData[1]
-	if uid, err = utils.Decrypt(encodedUID, []byte(viper.GetString("api.secret"))); err != nil {
-		return
-	}
-	if gid, err = utils.Decrypt(encodedGID, []byte(viper.GetString("api.secret"))); err != nil {
-		return
-	}
-	cid = encodedData[2]
+	uid, gid = encodedData[0], encodedData[1]
+	// if uid, err = utils.Decrypt(encodedUID, []byte(viper.GetString("api.secret"))); err != nil {
+	// 	return
+	// }
+	// if gid, err = utils.Decrypt(encodedGID, []byte(viper.GetString("api.secret"))); err != nil {
+	// 	return
+	// }
+	announce_cid = encodedData[2]
+	logging_cid = encodedData[3]
 	if len(encodedData) > 3 {
-		rid = encodedData[3:]
+		rid = encodedData[4:]
 	}
 	return
 }
diff --git a/pkg/commands/register.go b/pkg/commands/register.go
index 0578049..f28dac2 100644
--- a/pkg/commands/register.go
+++ b/pkg/commands/register.go
@@ -26,6 +26,13 @@ func RegisterSlashCommands(s *discordgo.Session) {
 		},
 		StatusCommand,
 	)
+	commands.Add(
+		&discordgo.ApplicationCommand{
+			Name:        "version",
+			Description: "Get the version of the bot.",
+		},
+		VersionCommand,
+	)
 	commands.Add(
 		&discordgo.ApplicationCommand{
 			Name:        "setup",
@@ -33,26 +40,39 @@ func RegisterSlashCommands(s *discordgo.Session) {
 			Options: []*discordgo.ApplicationCommandOption{
 				{
 					Type:        discordgo.ApplicationCommandOptionChannel,
-					Name:        "message-channel",
+					Name:        "announce-channel",
 					Description: "Default channel for whodis to send join announcements.",
 					Required:    true,
+				}, {
+					Type:        discordgo.ApplicationCommandOptionChannel,
+					Name:        "logging-channel",
+					Description: "Channel to send logs in.",
+					Required:    true,
 				}, {
 					Type:        discordgo.ApplicationCommandOptionRole,
-					Name:        "additional-role-1",
-					Description: "Additional role to be added to users on join.",
+					Name:        "given-role-1",
+					Description: "Optional role to add to users on registration.",
 					Required:    false,
 				}, {
 					Type:        discordgo.ApplicationCommandOptionRole,
-					Name:        "additional-role-2",
-					Description: "Additional role to be added to users on join.",
+					Name:        "given-role-2",
+					Description: "Optional additional role to add to users on registration.",
 					Required:    false,
 				},
 			},
 		},
 		SetupCommand,
 	)
+
+	// for _, com := range appCommands {
+	// 	commands.Add(com.Command, com.Handler)
+	// 	s.ApplicationCommandCreate(s.State.User.ID, viper.GetString("test.guild"), com.Command)
+	// }
+
 	commands.AddComponent("verify", VerifyCommand)
-	commands.Register(s)
+	if err := commands.Register(s); err != nil {
+		log.WithError(err).Error("Failed to register slash commands")
+	}
 }
 
 type CommandHandler func(ctx context.Context, s *discordgo.Session, i *discordgo.InteractionCreate) *interactionError
@@ -93,7 +113,7 @@ func (c *Commands) Register(s *discordgo.Session) error {
 			callComponentHandler(s, i)
 		}
 	})
-	if _, err := s.ApplicationCommandBulkOverwrite(viper.GetString("discord.app.id"), "", c.commands); err != nil {
+	if _, err := s.ApplicationCommandBulkOverwrite(viper.GetString("discord.app.id"), "976394713903009793", c.commands); err != nil {
 		log.WithError(err).Error("Failed to create commands")
 		return err
 	}
@@ -104,7 +124,7 @@ func checkDirectMessage(i *discordgo.InteractionCreate) (*discordgo.User, *inter
 	if i.GuildID == "" {
 		return nil, &interactionError{
 			errors.New("command invoked outside of valid guild"),
-			"This command is only available from inside a valid server",
+			"This command is only available in a valid server",
 		}
 	}
 	return i.Member.User, nil
@@ -114,7 +134,10 @@ func callComponentHandler(s *discordgo.Session, i *discordgo.InteractionCreate)
 	ctx := context.Background()
 	m := i.MessageComponentData()
 	if m.CustomID == "" {
-		iErr := &interactionError{errors.New("No custom_id assigned to component on message " + i.Message.ID), "Couldn't handle component, invalid custom_id"}
+		iErr := &interactionError{
+			errors.New("No custom_id assigned to component on message " + i.Message.ID),
+			"Couldn't handle component, invalid custom_id",
+		}
 		iErr.Handle(s, i)
 		return
 	}
@@ -145,19 +168,23 @@ func callCommandHandler(s *discordgo.Session, i *discordgo.InteractionCreate) {
 		iError.Handle(s, i)
 		return
 	}
+
 	commandName := i.ApplicationCommandData().Name
 	roleExists, roleAccess := botPermissionCheck(s, i.GuildID)
 	if commandName != "status" && !(roleExists && roleAccess) {
-		iError = &interactionError{errors.New("setup is not complete"), "Server setup not complete, please use the /status command"}
+		iError = &interactionError{
+			errors.New("setup is not complete"), "Server setup not complete, please use the /status command"}
 		iError.Handle(s, i)
 		return
 	}
+
 	channel, err := s.Channel(i.ChannelID)
 	if err != nil {
 		iError = &interactionError{err, "Couldn't query channel"}
 		iError.Handle(s, i)
 		return
 	}
+
 	if handler, ok := commands.handlers[commandName]; ok {
 		ctx := context.WithValue(ctx, log.Key, log.Fields{
 			"author_id":        commandAuthor.ID,
diff --git a/pkg/commands/setup.go b/pkg/commands/setup.go
index 4072785..33566f1 100644
--- a/pkg/commands/setup.go
+++ b/pkg/commands/setup.go
@@ -4,6 +4,7 @@ import (
 	"context"
 	"errors"
 
+	"github.com/UCCNetsoc/whodis/pkg/utils"
 	"github.com/bwmarrin/discordgo"
 )
 
@@ -17,7 +18,7 @@ func SetupCommand(ctx context.Context, s *discordgo.Session, i *discordgo.Intera
 		return &interactionError{err: err, message: "Unable to query guild"}
 	}
 	m := &discordgo.MessageSend{
-		Content: "Welcome @everyone to **" + g.Name + "**!",
+		Content: "Welcome to **" + g.Name + "**!",
 		Components: []discordgo.MessageComponent{
 			discordgo.ActionsRow{
 				Components: []discordgo.MessageComponent{
@@ -37,9 +38,14 @@ func SetupCommand(ctx context.Context, s *discordgo.Session, i *discordgo.Intera
 		Type: discordgo.InteractionResponseChannelMessageWithSource,
 		Data: &discordgo.InteractionResponseData{
 			Flags:   1 << 6, // Whisper Flag
-			Content: "This channel is now setup as the welcome room.\nMake sure users don't have send message permissions on this channel to avoid register message being buried by spam.",
+			Content: "This channel has been setup as the welcome room.\nMake sure users don't have send message permissions on this channel to avoid register message being buried by spam.",
 		},
 	}
+
+	utils.SendLogMessage(s, i.ApplicationCommandData().Options[1].ChannelValue(s).ID,
+		"This channel has been setup as the logging channel.\nDue to the stateless and privacy-conscious nature of Whodis, some errors may not get logged. It is advisable to keep a help channel for new members to who can't authenticate, in case logs don't reflect the errors.",
+	)
+
 	if err := s.InteractionRespond(i.Interaction, resp); err != nil {
 		return &interactionError{err: err, message: "Couldn't reply to interaction."}
 	}
@@ -48,7 +54,8 @@ func SetupCommand(ctx context.Context, s *discordgo.Session, i *discordgo.Intera
 
 func concatData(ctx context.Context, s *discordgo.Session, i *discordgo.InteractionCreate) string {
 	data := "." + i.ApplicationCommandData().Options[0].ChannelValue(s).ID
-	for _, role := range i.ApplicationCommandData().Options[1:] {
+	data += "." + i.ApplicationCommandData().Options[1].ChannelValue(s).ID
+	for _, role := range i.ApplicationCommandData().Options[2:] {
 		data += "." + role.RoleValue(s, i.GuildID).ID
 	}
 	return data
diff --git a/pkg/commands/verify.go b/pkg/commands/verify.go
index b5334d2..9b70e03 100644
--- a/pkg/commands/verify.go
+++ b/pkg/commands/verify.go
@@ -11,7 +11,7 @@ import (
 	"github.com/spf13/viper"
 )
 
-// VerifyCommand inits the verification process.
+// VerifyCommand creates a button component with encrypted & signed state specific to the user to go through OAuth flow.
 func VerifyCommand(ctx context.Context, s *discordgo.Session, i *discordgo.InteractionCreate) *interactionError {
 	user := i.Member.User
 	guildID := i.GuildID
@@ -33,35 +33,37 @@ func VerifyCommand(ctx context.Context, s *discordgo.Session, i *discordgo.Inter
 	for _, roleID := range i.Member.Roles {
 		roleName, ok := guildRoleNames[roleID]
 		if ok && roleName == viper.GetString("discord.member.role") {
-			return &interactionError{errors.New("member role is already assigned to user"), "You are already assigned the `" + viper.GetString("discord.member.role") + "` role."}
+			return &interactionError{
+				errors.New("member role is already assigned to user"), "You are already assigned the `" +
+					viper.GetString("discord.member.role") + "` role.",
+			}
 		}
 	}
 
-	uid, err := utils.Encrypt(user.ID, []byte(viper.GetString("api.secret")))
-	if err != nil {
-		return &interactionError{err, "Failed to encrypt userID"}
-	}
-
-	gid, err := utils.Encrypt(guild.ID, []byte(viper.GetString("api.secret")))
-	if err != nil {
-		return &interactionError{err, "Failed to encrypt guildID"}
-	}
-
-	encoded, err := utils.Encrypt(fmt.Sprintf("%s.%s.%s", uid, gid, i.MessageComponentData().CustomID[2:]), []byte(viper.GetString("api.secret")))
+	// encode the userID, guildID, ( welcome channel, logging channel, and roles to give to verified user )
+	encoded, err := utils.Encrypt(
+		fmt.Sprintf("%s.%s.%s", user.ID, guild.ID, i.MessageComponentData().CustomID[2:]), []byte(viper.GetString("api.secret")),
+	)
 	if err != nil {
+		// utils.SendLogMessage(s, i.MessageComponentData().CustomID[2:], "Failed to encrypt data")
 		return &interactionError{err, "Failed to encrypt user info digest"}
 	}
 
 	err = s.InteractionRespond(i.Interaction, &discordgo.InteractionResponse{
 		Type: discordgo.InteractionResponseChannelMessageWithSource,
 		Data: &discordgo.InteractionResponseData{
-			Content: fmt.Sprintf("Hey **%s**! Welcome to **%s**!\nJust click the link below and make sure to signin with your **%s** account.", user.Username, guild.Name, viper.GetString("oauth.google.domain")),
-			Flags:   1 << 6, // Whisper Flag
+			Content: fmt.Sprintf(
+				"Hey **%s**! Welcome to **%s**!\nClick the link below and make sure to sign in with your %s account.",
+				user.Username, guild.Name, viper.GetString("oauth.google.domain"),
+			),
+			Flags: 1 << 6, // Whisper Flag
 			Components: []discordgo.MessageComponent{
 				discordgo.ActionsRow{
 					Components: []discordgo.MessageComponent{
 						discordgo.Button{
-							Label:    "Click here to register your " + viper.GetString("oauth.google.domain") + " account.",
+							Label: fmt.Sprintf("Click here to register your %s %s", viper.GetString(
+								"oauth.google.domain"), " account.",
+							),
 							Style:    discordgo.LinkButton,
 							Disabled: false,
 							URL:      viper.GetString("api.url") + "/discord/auth?state=" + encoded,
@@ -81,7 +83,7 @@ func VerifyCommand(ctx context.Context, s *discordgo.Session, i *discordgo.Inter
 				discordgo.ActionsRow{
 					Components: []discordgo.MessageComponent{
 						discordgo.Button{
-							Label:    "Button has timed out, use /verify or click registration button to try again!",
+							Label:    "Button timed out. Use /verify or click the registration button again to retry!",
 							Style:    discordgo.LinkButton,
 							Disabled: true,
 							URL:      "https://netsoc.co/rk",
diff --git a/pkg/commands/version.go b/pkg/commands/version.go
new file mode 100644
index 0000000..a6f180b
--- /dev/null
+++ b/pkg/commands/version.go
@@ -0,0 +1,35 @@
+package commands
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/bwmarrin/discordgo"
+	"github.com/spf13/viper"
+)
+
+func VersionCommand(ctx context.Context, s *discordgo.Session, i *discordgo.InteractionCreate) *interactionError {
+	version := viper.GetString("bot.version")
+	response := &discordgo.InteractionResponse{
+		Type: discordgo.InteractionResponseChannelMessageWithSource,
+		Data: &discordgo.InteractionResponseData{
+			Embeds: []*discordgo.MessageEmbed{
+				{
+					Title: "Whodis Version",
+					Fields: []*discordgo.MessageEmbedField{
+						{
+							Name:   "Version",
+							Value:  fmt.Sprintf("[%s](https://github.com/UCCNetsoc/whodis/releases/tag/%s)", version, version),
+							Inline: true,
+						},
+					},
+				},
+			},
+		},
+	}
+	if err := s.InteractionRespond(i.Interaction, response); err != nil {
+		return &interactionError{err, err.Error()}
+	}
+
+	return nil
+}
diff --git a/pkg/utils/hash.go b/pkg/utils/hash.go
index b3e3269..2eec79c 100644
--- a/pkg/utils/hash.go
+++ b/pkg/utils/hash.go
@@ -8,7 +8,7 @@ import (
 	"io"
 )
 
-// encrypt encrypts plain string with a secret key and returns encrypt string. !!Secret must be 32 byte string!!
+// Encrypt encrypts state with a secret key. !!secret must be 32 byte string!!
 func Encrypt(plainData string, secret []byte) (string, error) {
 	cipherBlock, err := aes.NewCipher(secret)
 	if err != nil {
@@ -27,7 +27,7 @@ func Encrypt(plainData string, secret []byte) (string, error) {
 	return base64.URLEncoding.EncodeToString(aead.Seal(nonce, nonce, []byte(plainData), nil)), nil
 }
 
-// decrypt decrypts encrypt string with a secret key and returns plain string.
+// Decrypt decrypts encrypted string with a secret key and returns plain string.
 func Decrypt(encodedData string, secret []byte) (string, error) {
 	encryptData, err := base64.URLEncoding.DecodeString(encodedData)
 	if err != nil {
diff --git a/pkg/utils/log.go b/pkg/utils/log.go
new file mode 100644
index 0000000..833b713
--- /dev/null
+++ b/pkg/utils/log.go
@@ -0,0 +1,14 @@
+package utils
+
+import (
+	"github.com/Strum355/log"
+	"github.com/bwmarrin/discordgo"
+)
+
+// SendMessage sends a message to the provided logging channel
+func SendLogMessage(s *discordgo.Session, channelId string, message interface{}) {
+	_, err := s.ChannelMessageSend(channelId, message.(string))
+	if err != nil {
+		log.WithError(err)
+	}
+}
diff --git a/template.env b/template.env
new file mode 100644
index 0000000..29f6f34
--- /dev/null
+++ b/template.env
@@ -0,0 +1,8 @@
+OAUTH_GOOGLE_ID=
+OAUTH_GOOGLE_SECRET=
+
+DISCORD_APP_ID=
+DISCORD_TOKEN=
+
+API_URL=
+API_SECRET=