diff --git a/.github/workflows/ci_run_custom_key_ops_cfg.json b/.github/workflows/ci_run_custom_key_ops_cfg.json
index 7ad726462..2ed5b991b 100644
--- a/.github/workflows/ci_run_custom_key_ops_cfg.json
+++ b/.github/workflows/ci_run_custom_key_ops_cfg.json
@@ -1,8 +1,8 @@
 {
     "language": "Java",
-    "sample_file": "samples/CustomKeyOpsPubSub",
+    "sample_file": "samples/CustomKeyOpsConnect",
     "sample_region": "us-east-1",
-    "sample_main_class": "customkeyopspubsub.CustomKeyOpsPubSub",
+    "sample_main_class": "customkeyopsconnect.CustomKeyOpsConnect",
     "arguments": [
         {
             "name": "--endpoint",
diff --git a/.github/workflows/ci_run_fleet_provisioning_cfg.json b/.github/workflows/ci_run_fleet_provisioning_cfg.json
index a064037a4..77f3a575f 100644
--- a/.github/workflows/ci_run_fleet_provisioning_cfg.json
+++ b/.github/workflows/ci_run_fleet_provisioning_cfg.json
@@ -1,8 +1,8 @@
 {
     "language": "Java",
-    "sample_file": "samples/Identity",
+    "sample_file": "samples/FleetProvisioning",
     "sample_region": "us-east-1",
-    "sample_main_class": "identity.FleetProvisioningSample",
+    "sample_main_class": "fleetprovisioning.FleetProvisioningSample",
     "arguments": [
         {
             "name": "--endpoint",
diff --git a/android/app/build.gradle b/android/app/build.gradle
index b3d77e0aa..8585b667f 100644
--- a/android/app/build.gradle
+++ b/android/app/build.gradle
@@ -21,7 +21,6 @@ android {
         main {
             java.srcDir '../../samples/BasicPubSub/src/main/java'
             java.srcDir '../../samples/Jobs/src/main/java'
-            java.srcDir '../../samples/PubSubStress/src/main/java'
             java.srcDir '../../samples/Shadow/src/main/java'
             java.srcDir 'src/main/java'
         }
diff --git a/android/app/src/main/java/software/amazon/awssdk/iotsamples/MainActivity.kt b/android/app/src/main/java/software/amazon/awssdk/iotsamples/MainActivity.kt
index 016199601..21a2d3623 100644
--- a/android/app/src/main/java/software/amazon/awssdk/iotsamples/MainActivity.kt
+++ b/android/app/src/main/java/software/amazon/awssdk/iotsamples/MainActivity.kt
@@ -17,8 +17,7 @@ import kotlin.concurrent.thread
 val SAMPLES = mapOf(
     "Publish/Subscribe Sample" to "pubsub.PubSub",
     "Jobs Client Sample" to "jobs.JobsSample",
-    "Shadow Client Sample" to "shadow.ShadowSample",
-    "Publish/Subscribe Load Test" to "pubsubstress.PubSubStress"
+    "Shadow Client Sample" to "shadow.ShadowSample"
 )
 
 class MainActivity : AppCompatActivity(), AdapterView.OnItemSelectedListener {
diff --git a/codebuild/samples/custom-key-ops-linux.sh b/codebuild/samples/custom-key-ops-linux.sh
index 57a887566..184d1e081 100755
--- a/codebuild/samples/custom-key-ops-linux.sh
+++ b/codebuild/samples/custom-key-ops-linux.sh
@@ -4,13 +4,13 @@ set -e
 set -o pipefail
 env
 
-pushd $CODEBUILD_SRC_DIR/samples/CustomKeyOpsPubSub
+pushd $CODEBUILD_SRC_DIR/samples/CustomKeyOpsConnect
 
 ENDPOINT=$(aws secretsmanager get-secret-value --secret-id "ci/endpoint" --query "SecretString" | cut -f2 -d":" | sed -e 's/[\\\"\}]//g')
 
 mvn compile
 
 echo "Custom Key Ops test"
-mvn exec:java -Dexec.mainClass="customkeyopspubsub.CustomKeyOpsPubSub" -Daws.crt.ci="True" -Dexec.arguments="--endpoint,$ENDPOINT,--key,/tmp/privatekey_p8.pem,--cert,/tmp/certificate.pem"
+mvn exec:java -Dexec.mainClass="customkeyopsconnect.CustomKeyOpsConnect" -Daws.crt.ci="True" -Dexec.arguments="--endpoint,$ENDPOINT,--key,/tmp/privatekey_p8.pem,--cert,/tmp/certificate.pem"
 
 popd
diff --git a/codebuild/samples/customkeyops-linux.sh b/codebuild/samples/customkeyops-linux.sh
index aadd6a724..e9b72695c 100755
--- a/codebuild/samples/customkeyops-linux.sh
+++ b/codebuild/samples/customkeyops-linux.sh
@@ -4,13 +4,13 @@ set -e
 
 env
 
-pushd $CODEBUILD_SRC_DIR/samples/CustomKeyOpsPubSub
+pushd $CODEBUILD_SRC_DIR/samples/CustomKeyOpsConnect
 
 ENDPOINT=$(aws secretsmanager get-secret-value --secret-id "unit-test/endpoint" --query "SecretString" | cut -f2 -d":" | sed -e 's/[\\\"\}]//g')
 
 mvn compile
 
 echo "Custom Key Ops test"
-mvn exec:java -Dexec.mainClass="customkeyopspubsub.CustomKeyOpsPubSub" -Daws.crt.ci="True" -Dexec.arguments="--endpoint,$ENDPOINT,--key,/tmp/privatekey_p8.pem,--cert,/tmp/certificate.pem"
+mvn exec:java -Dexec.mainClass="customkeyopsconnect.CustomKeyOpsConnect" -Daws.crt.ci="True" -Dexec.arguments="--endpoint,$ENDPOINT,--key,/tmp/privatekey_p8.pem,--cert,/tmp/certificate.pem"
 
 popd
diff --git a/documents/MQTT5_Userguide.md b/documents/MQTT5_Userguide.md
index 68a0c6786..d18b94cba 100644
--- a/documents/MQTT5_Userguide.md
+++ b/documents/MQTT5_Userguide.md
@@ -27,7 +27,7 @@
 
 MQTT5 support is currently in **developer preview**. We encourage feedback at all times, but feedback during the preview window is especially valuable in shaping the final product. During the preview period we may make backwards-incompatible changes to the public API, but in general, this is something we will try our best to avoid.
 
-The MQTT5 client cannot yet be used with the AWS IoT MQTT services (Shadow, Jobs, Identity). We plan to address this in the near future.
+The MQTT5 client cannot yet be used with the AWS IoT MQTT services (Shadow, Jobs, Fleet-Provisioning/Identity). We plan to address this in the near future.
 
 # Introduction
 
@@ -221,7 +221,7 @@ A MQTT5 direct connection can be made with a set of custom private key operation
 ~~~ java
 class MyKeyOperationHandler implements TlsKeyOperationHandler {
 
-    // Implement based on the operation. See CustomKeyOpsPubSub sample for example
+    // Implement based on the operation. See CustomKeyOpsConnect sample for example
     public void performOperation(TlsKeyOperation operation) {
         try {
             throw new RuntimeException("This is just an example!");
diff --git a/pom.xml b/pom.xml
index 7bc986721..e847307be 100644
--- a/pom.xml
+++ b/pom.xml
@@ -12,7 +12,6 @@
         <module>samples/BasicConnect</module>
         <module>samples/WebsocketConnect</module>
         <module>samples/X509CredentialsProviderConnect</module>
-        <module>samples/RawConnect</module>
         <module>samples/Pkcs11Connect</module>
         <module>samples/CustomAuthorizerConnect</module>
         <module>samples/JavaKeystoreConnect</module>
@@ -20,11 +19,10 @@
         <module>samples/Greengrass</module>
         <module>samples/GreengrassIPC</module>
         <module>samples/Jobs</module>
-        <module>samples/PubSubStress</module>
-        <module>samples/CustomKeyOpsPubSub</module>
+        <module>samples/CustomKeyOpsConnect</module>
         <module>samples/WindowsCertConnect</module>
         <module>samples/Shadow</module>
-        <module>samples/Identity</module>
+        <module>samples/FleetProvisioning</module>
         <module>samples/Mqtt5/PubSub</module>
         <module>samples/Mqtt5/SharedSubscription</module>
     </modules>
diff --git a/samples/BasicConnect/src/main/java/basicconnect/BasicConnect.java b/samples/BasicConnect/src/main/java/basicconnect/BasicConnect.java
index 4fdfe301c..fe5468466 100644
--- a/samples/BasicConnect/src/main/java/basicconnect/BasicConnect.java
+++ b/samples/BasicConnect/src/main/java/basicconnect/BasicConnect.java
@@ -8,29 +8,26 @@
 import software.amazon.awssdk.crt.CRT;
 import software.amazon.awssdk.crt.CrtResource;
 import software.amazon.awssdk.crt.CrtRuntimeException;
-import software.amazon.awssdk.crt.io.ClientBootstrap;
 import software.amazon.awssdk.crt.mqtt.MqttClientConnection;
 import software.amazon.awssdk.crt.mqtt.MqttClientConnectionEvents;
-import software.amazon.awssdk.iot.iotjobs.model.RejectedError;
+import software.amazon.awssdk.crt.http.HttpProxyOptions;
+import software.amazon.awssdk.iot.AwsIotMqttConnectionBuilder;
 
 import java.util.concurrent.ExecutionException;
+import java.util.concurrent.CompletableFuture;
 
 import utils.commandlineutils.CommandLineUtils;
 
 public class BasicConnect {
 
-    // When run normally, we want to exit nicely even if something goes wrong
+    // When run normally, we want to exit nicely even if something goes wrong.
     // When run from CI, we want to let an exception escape which in turn causes the
-    // exec:java task to return a non-zero exit code
+    // exec:java task to return a non-zero exit code.
     static String ciPropValue = System.getProperty("aws.crt.ci");
     static boolean isCI = ciPropValue != null && Boolean.valueOf(ciPropValue);
 
     static CommandLineUtils cmdUtils;
 
-    static void onRejectedError(RejectedError error) {
-        System.out.println("Request rejected: " + error.code.toString() + ": " + error.message);
-    }
-
     /*
      * When called during a CI run, throw an exception that will escape and fail the exec:java task
      * When called otherwise, print what went wrong (if anything) and just continue (return from main)
@@ -45,15 +42,12 @@ static void onApplicationFailure(Throwable cause) {
 
     public static void main(String[] args) {
 
-        cmdUtils = new CommandLineUtils();
-        cmdUtils.registerProgramName("BasicConnect");
-        cmdUtils.addCommonMQTTCommands();
-        cmdUtils.addCommonProxyCommands();
-        cmdUtils.registerCommand("key", "<path>", "Path to your key in PEM format.");
-        cmdUtils.registerCommand("cert", "<path>", "Path to your client certificate in PEM format.");
-        cmdUtils.registerCommand("client_id", "<int>", "Client id to use (optional, default='test-*').");
-        cmdUtils.registerCommand("port", "<int>", "Port to connect to on the endpoint (optional, default='8883').");
-        cmdUtils.sendArguments(args);
+        /**
+         * cmdData is the arguments/input from the command line placed into a single struct for
+         * use in this sample. This handles all of the command line parsing, validating, etc.
+         * See the Utils/CommandLineUtils for more information.
+         */
+        CommandLineUtils.SampleCommandLineData cmdData = CommandLineUtils.getInputForIoTSample("BasicConnect", args);
 
         MqttClientConnectionEvents callbacks = new MqttClientConnectionEvents() {
             @Override
@@ -71,20 +65,54 @@ public void onConnectionResumed(boolean sessionPresent) {
 
         try {
 
-            // Create a connection using a certificate and key
-            // Note: The data for the connection is gotten from cmdUtils.
-            // (see buildDirectMQTTConnection for implementation)
-            MqttClientConnection connection = cmdUtils.buildDirectMQTTConnection(callbacks);
+            /**
+             * Create the MQTT connection from the builder
+             */
+            AwsIotMqttConnectionBuilder builder = AwsIotMqttConnectionBuilder.newMtlsBuilderFromPath(cmdData.input_cert, cmdData.input_key);
+            if (cmdData.input_ca != "") {
+                builder.withCertificateAuthorityFromPath(null, cmdData.input_ca);
+            }
+            builder.withConnectionEventCallbacks(callbacks)
+                .withClientId(cmdData.input_clientId)
+                .withEndpoint(cmdData.input_endpoint)
+                .withPort((short)cmdData.input_port)
+                .withCleanSession(true)
+                .withProtocolOperationTimeoutMs(60000);
+            if (cmdData.input_proxyHost != "" && cmdData.input_proxyPort > 0) {
+                HttpProxyOptions proxyOptions = new HttpProxyOptions();
+                proxyOptions.setHost(cmdData.input_proxyHost);
+                proxyOptions.setPort(cmdData.input_proxyPort);
+                builder.withHttpProxyOptions(proxyOptions);
+            }
+            MqttClientConnection connection = builder.build();
+            builder.close();
+
+            /**
+             * Verify the connection was created
+             */
             if (connection == null)
             {
                 onApplicationFailure(new RuntimeException("MQTT connection creation failed!"));
             }
 
-            // Connect and disconnect using the connection we created
-            // (see sampleConnectAndDisconnect for implementation)
-            cmdUtils.sampleConnectAndDisconnect(connection);
-
-            // Close the connection now that we are completely done with it.
+            /**
+             * Connect and disconnect
+             */
+            CompletableFuture<Boolean> connected = connection.connect();
+            try {
+                boolean sessionPresent = connected.get();
+                System.out.println("Connected to " + (!sessionPresent ? "new" : "existing") + " session!");
+            } catch (Exception ex) {
+                throw new RuntimeException("Exception occurred during connect", ex);
+            }
+            System.out.println("Disconnecting...");
+            CompletableFuture<Void> disconnected = connection.disconnect();
+            disconnected.get();
+            System.out.println("Disconnected.");
+
+            /**
+             * Close the connection now that it is complete
+             */
             connection.close();
 
         } catch (CrtRuntimeException | InterruptedException | ExecutionException ex) {
diff --git a/samples/BasicPubSub/src/main/java/pubsub/PubSub.java b/samples/BasicPubSub/src/main/java/pubsub/PubSub.java
index cbc7ce367..a3e2b64c5 100644
--- a/samples/BasicPubSub/src/main/java/pubsub/PubSub.java
+++ b/samples/BasicPubSub/src/main/java/pubsub/PubSub.java
@@ -8,21 +8,14 @@
 import software.amazon.awssdk.crt.CRT;
 import software.amazon.awssdk.crt.CrtResource;
 import software.amazon.awssdk.crt.CrtRuntimeException;
-import software.amazon.awssdk.crt.Log;
-import software.amazon.awssdk.crt.auth.credentials.X509CredentialsProvider;
 import software.amazon.awssdk.crt.http.HttpProxyOptions;
-import software.amazon.awssdk.crt.io.ClientBootstrap;
-import software.amazon.awssdk.crt.io.ClientTlsContext;
-import software.amazon.awssdk.crt.io.TlsContextOptions;
 import software.amazon.awssdk.crt.mqtt.MqttClientConnection;
 import software.amazon.awssdk.crt.mqtt.MqttClientConnectionEvents;
 import software.amazon.awssdk.crt.mqtt.MqttMessage;
 import software.amazon.awssdk.crt.mqtt.QualityOfService;
 import software.amazon.awssdk.iot.AwsIotMqttConnectionBuilder;
-import software.amazon.awssdk.iot.iotjobs.model.RejectedError;
 
 import java.nio.charset.StandardCharsets;
-import java.util.UUID;
 import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.CountDownLatch;
 import java.util.concurrent.ExecutionException;
@@ -37,16 +30,8 @@ public class PubSub {
     static String ciPropValue = System.getProperty("aws.crt.ci");
     static boolean isCI = ciPropValue != null && Boolean.valueOf(ciPropValue);
 
-    static String topic = "test/topic";
-    static String message = "Hello World!";
-    static int    messagesToPublish = 10;
-
     static CommandLineUtils cmdUtils;
 
-    static void onRejectedError(RejectedError error) {
-        System.out.println("Request rejected: " + error.code.toString() + ": " + error.message);
-    }
-
     /*
      * When called during a CI run, throw an exception that will escape and fail the exec:java task
      * When called otherwise, print what went wrong (if anything) and just continue (return from main)
@@ -61,20 +46,12 @@ static void onApplicationFailure(Throwable cause) {
 
     public static void main(String[] args) {
 
-        cmdUtils = new CommandLineUtils();
-        cmdUtils.registerProgramName("PubSub");
-        cmdUtils.addCommonMQTTCommands();
-        cmdUtils.addCommonTopicMessageCommands();
-        cmdUtils.registerCommand("key", "<path>", "Path to your key in PEM format.");
-        cmdUtils.registerCommand("cert", "<path>", "Path to your client certificate in PEM format.");
-        cmdUtils.registerCommand("client_id", "<int>", "Client id to use (optional, default='test-*').");
-        cmdUtils.registerCommand("port", "<int>", "Port to connect to on the endpoint (optional, default='8883').");
-        cmdUtils.registerCommand("count", "<int>", "Number of messages to publish (optional, default='10').");
-        cmdUtils.sendArguments(args);
-
-        topic = cmdUtils.getCommandOrDefault("topic", topic);
-        message = cmdUtils.getCommandOrDefault("message", message);
-        messagesToPublish = Integer.parseInt(cmdUtils.getCommandOrDefault("count", String.valueOf(messagesToPublish)));
+        /**
+         * cmdData is the arguments/input from the command line placed into a single struct for
+         * use in this sample. This handles all of the command line parsing, validating, etc.
+         * See the Utils/CommandLineUtils for more information.
+         */
+        CommandLineUtils.SampleCommandLineData cmdData = CommandLineUtils.getInputForIoTSample("PubSub", args);
 
         MqttClientConnectionEvents callbacks = new MqttClientConnectionEvents() {
             @Override
@@ -92,12 +69,29 @@ public void onConnectionResumed(boolean sessionPresent) {
 
         try {
 
-            MqttClientConnection connection = cmdUtils.buildMQTTConnection(callbacks);
-            if (connection == null)
-            {
-                onApplicationFailure(new RuntimeException("MQTT connection creation failed!"));
+            /**
+             * Create the MQTT connection from the builder
+             */
+            AwsIotMqttConnectionBuilder builder = AwsIotMqttConnectionBuilder.newMtlsBuilderFromPath(cmdData.input_cert, cmdData.input_key);
+            if (cmdData.input_ca != "") {
+                builder.withCertificateAuthorityFromPath(null, cmdData.input_ca);
+            }
+            builder.withConnectionEventCallbacks(callbacks)
+                .withClientId(cmdData.input_clientId)
+                .withEndpoint(cmdData.input_endpoint)
+                .withPort((short)cmdData.input_port)
+                .withCleanSession(true)
+                .withProtocolOperationTimeoutMs(60000);
+            if (cmdData.input_proxyHost != "" && cmdData.input_proxyPort > 0) {
+                HttpProxyOptions proxyOptions = new HttpProxyOptions();
+                proxyOptions.setHost(cmdData.input_proxyHost);
+                proxyOptions.setPort(cmdData.input_proxyPort);
+                builder.withHttpProxyOptions(proxyOptions);
             }
+            MqttClientConnection connection = builder.build();
+            builder.close();
 
+            // Connect the MQTT client
             CompletableFuture<Boolean> connected = connection.connect();
             try {
                 boolean sessionPresent = connected.get();
@@ -106,25 +100,25 @@ public void onConnectionResumed(boolean sessionPresent) {
                 throw new RuntimeException("Exception occurred during connect", ex);
             }
 
-            CountDownLatch countDownLatch = new CountDownLatch(messagesToPublish);
-
-            CompletableFuture<Integer> subscribed = connection.subscribe(topic, QualityOfService.AT_LEAST_ONCE, (message) -> {
+            // Subscribe to the topic
+            CountDownLatch countDownLatch = new CountDownLatch(cmdData.input_count);
+            CompletableFuture<Integer> subscribed = connection.subscribe(cmdData.input_topic, QualityOfService.AT_LEAST_ONCE, (message) -> {
                 String payload = new String(message.getPayload(), StandardCharsets.UTF_8);
                 System.out.println("MESSAGE: " + payload);
                 countDownLatch.countDown();
             });
-
             subscribed.get();
 
+            // Publish to the topic
             int count = 0;
-            while (count++ < messagesToPublish) {
-                CompletableFuture<Integer> published = connection.publish(new MqttMessage(topic, message.getBytes(), QualityOfService.AT_LEAST_ONCE, false));
+            while (count++ < cmdData.input_count) {
+                CompletableFuture<Integer> published = connection.publish(new MqttMessage(cmdData.input_topic, cmdData.input_message.getBytes(), QualityOfService.AT_LEAST_ONCE, false));
                 published.get();
                 Thread.sleep(1000);
             }
-
             countDownLatch.await();
 
+            // Disconnect
             CompletableFuture<Void> disconnected = connection.disconnect();
             disconnected.get();
 
diff --git a/samples/CognitoConnect/src/main/java/cognitoconnect/CognitoConnect.java b/samples/CognitoConnect/src/main/java/cognitoconnect/CognitoConnect.java
index 5874543a2..2e8a7b9bd 100644
--- a/samples/CognitoConnect/src/main/java/cognitoconnect/CognitoConnect.java
+++ b/samples/CognitoConnect/src/main/java/cognitoconnect/CognitoConnect.java
@@ -10,8 +10,14 @@
 import software.amazon.awssdk.crt.CrtRuntimeException;
 import software.amazon.awssdk.crt.mqtt.MqttClientConnection;
 import software.amazon.awssdk.crt.mqtt.MqttClientConnectionEvents;
-import software.amazon.awssdk.iot.iotjobs.model.RejectedError;
-
+import software.amazon.awssdk.crt.http.HttpProxyOptions;
+import software.amazon.awssdk.crt.auth.credentials.CognitoCredentialsProvider;
+import software.amazon.awssdk.crt.io.ClientBootstrap;
+import software.amazon.awssdk.crt.io.TlsContextOptions;
+import software.amazon.awssdk.crt.io.ClientTlsContext;
+import software.amazon.awssdk.iot.AwsIotMqttConnectionBuilder;
+
+import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.ExecutionException;
 
 import utils.commandlineutils.CommandLineUtils;
@@ -39,14 +45,12 @@ static void onApplicationFailure(Throwable cause) {
 
     public static void main(String[] args) {
 
-        cmdUtils = new CommandLineUtils();
-        cmdUtils.registerProgramName("CognitoConnect");
-        cmdUtils.addCommonMQTTCommands();
-        cmdUtils.addCommonProxyCommands();
-        cmdUtils.registerCommand("signing_region", "<str>", "AWS IoT service region.");
-        cmdUtils.registerCommand("client_id", "<int>", "Client id to use (optional, default='test-*').");
-        cmdUtils.registerCommand("cognito_identity", "<str>", "The Cognito identity ID to use to connect via Cognito");
-        cmdUtils.sendArguments(args);
+        /**
+         * cmdData is the arguments/input from the command line placed into a single struct for
+         * use in this sample. This handles all of the command line parsing, validating, etc.
+         * See the Utils/CommandLineUtils for more information.
+         */
+        CommandLineUtils.SampleCommandLineData cmdData = CommandLineUtils.getInputForIoTSample("CognitoConnect", args);
 
         MqttClientConnectionEvents callbacks = new MqttClientConnectionEvents() {
             @Override
@@ -63,10 +67,9 @@ public void onConnectionResumed(boolean sessionPresent) {
         };
 
         try {
+
             /**
              * Creates a connection using Cognito credentials.
-             * Note: The data for the connection is gotten from cmdUtils.
-             * (see buildCognitoMQTTConnection for implementation)
              *
              * Note: This sample and code assumes that you are using a Cognito identity
              * in the same region as you pass to "--signing_region".
@@ -74,17 +77,59 @@ public void onConnectionResumed(boolean sessionPresent) {
              * See https://docs.aws.amazon.com/general/latest/gr/cognito_identity.html
              * for all Cognito endpoints.
              */
-            MqttClientConnection connection = cmdUtils.buildCognitoMQTTConnection(callbacks);
+            // =================================
+            AwsIotMqttConnectionBuilder builder = AwsIotMqttConnectionBuilder.newMtlsBuilderFromPath(null, null);
+            builder.withConnectionEventCallbacks(callbacks)
+                .withClientId(cmdData.input_clientId)
+                .withEndpoint(cmdData.input_endpoint)
+                .withCleanSession(true)
+                .withProtocolOperationTimeoutMs(60000);
+
+            builder.withWebsockets(true);
+            builder.withWebsocketSigningRegion(cmdData.input_signingRegion);
+
+            CognitoCredentialsProvider.CognitoCredentialsProviderBuilder cognitoBuilder = new CognitoCredentialsProvider.CognitoCredentialsProviderBuilder();
+            String cognitoEndpoint = "cognito-identity." + cmdData.input_signingRegion + ".amazonaws.com";
+            cognitoBuilder.withEndpoint(cognitoEndpoint).withIdentity(cmdData.input_cognitoIdentity);
+            cognitoBuilder.withClientBootstrap(ClientBootstrap.getOrCreateStaticDefault());
+
+            TlsContextOptions cognitoTlsContextOptions = TlsContextOptions.createDefaultClient();
+            ClientTlsContext cognitoTlsContext = new ClientTlsContext(cognitoTlsContextOptions);
+            cognitoTlsContextOptions.close();
+            cognitoBuilder.withTlsContext(cognitoTlsContext);
+
+            CognitoCredentialsProvider cognitoCredentials = cognitoBuilder.build();
+            builder.withWebsocketCredentialsProvider(cognitoCredentials);
+
+            MqttClientConnection connection = builder.build();
+            builder.close();
+            cognitoCredentials.close();
+            cognitoTlsContext.close();
+
             if (connection == null)
             {
                 onApplicationFailure(new RuntimeException("MQTT connection creation failed!"));
             }
+            // =================================
 
-            // Connect and disconnect using the connection we created
-            // (see sampleConnectAndDisconnect for implementation)
-            cmdUtils.sampleConnectAndDisconnect(connection);
+            /**
+             * Connect and disconnect
+             */
+            CompletableFuture<Boolean> connected = connection.connect();
+            try {
+                boolean sessionPresent = connected.get();
+                System.out.println("Connected to " + (!sessionPresent ? "new" : "existing") + " session!");
+            } catch (Exception ex) {
+                throw new RuntimeException("Exception occurred during connect", ex);
+            }
+            System.out.println("Disconnecting...");
+            CompletableFuture<Void> disconnected = connection.disconnect();
+            disconnected.get();
+            System.out.println("Disconnected.");
 
-            // Close the connection now that we are completely done with it.
+            /**
+             * Close the connection now that it is complete
+             */
             connection.close();
 
         } catch (CrtRuntimeException | InterruptedException | ExecutionException ex) {
diff --git a/samples/CustomAuthorizerConnect/src/main/java/customauthorizerconnect/CustomAuthorizerConnect.java b/samples/CustomAuthorizerConnect/src/main/java/customauthorizerconnect/CustomAuthorizerConnect.java
index f1880067e..8f92fe079 100644
--- a/samples/CustomAuthorizerConnect/src/main/java/customauthorizerconnect/CustomAuthorizerConnect.java
+++ b/samples/CustomAuthorizerConnect/src/main/java/customauthorizerconnect/CustomAuthorizerConnect.java
@@ -8,12 +8,13 @@
 import software.amazon.awssdk.crt.CRT;
 import software.amazon.awssdk.crt.CrtResource;
 import software.amazon.awssdk.crt.CrtRuntimeException;
-import software.amazon.awssdk.crt.io.ClientBootstrap;
 import software.amazon.awssdk.crt.mqtt.MqttClientConnection;
 import software.amazon.awssdk.crt.mqtt.MqttClientConnectionEvents;
-import software.amazon.awssdk.iot.iotjobs.model.RejectedError;
+import software.amazon.awssdk.iot.AwsIotMqttConnectionBuilder;
 
+import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.ExecutionException;
+import java.io.UnsupportedEncodingException;
 
 import utils.commandlineutils.CommandLineUtils;
 
@@ -39,15 +40,13 @@ static void onApplicationFailure(Throwable cause) {
     }
 
     public static void main(String[] args) {
-        cmdUtils = new CommandLineUtils();
-        cmdUtils.registerProgramName("CustomAuthorizerConnect");
-        cmdUtils.addCommonMQTTCommands();
-        cmdUtils.registerCommand("client_id", "<int>", "Client id to use (optional, default='test-*').");
-        cmdUtils.registerCommand("custom_auth_username", "<str>", "Username for connecting to custom authorizer (optional, default=null).");
-        cmdUtils.registerCommand("custom_auth_authorizer_name", "<str>", "Name of custom authorizer (optional, default=null).");
-        cmdUtils.registerCommand("custom_auth_authorizer_signature", "<str>", "Signature passed when connecting to custom authorizer (optional, default=null).");
-        cmdUtils.registerCommand("custom_auth_password", "<str>", "Password for connecting to custom authorizer (optional, default=null).");
-        cmdUtils.sendArguments(args);
+
+        /**
+         * cmdData is the arguments/input from the command line placed into a single struct for
+         * use in this sample. This handles all of the command line parsing, validating, etc.
+         * See the Utils/CommandLineUtils for more information.
+         */
+        CommandLineUtils.SampleCommandLineData cmdData = CommandLineUtils.getInputForIoTSample("CustomAuthorizerConnect", args);
 
         MqttClientConnectionEvents callbacks = new MqttClientConnectionEvents() {
             @Override
@@ -65,23 +64,50 @@ public void onConnectionResumed(boolean sessionPresent) {
 
         try {
 
-            // Create a connection authenticated via a custom authorizer.
-            // Note: The data for the connection is gotten from cmdUtils.
-            // (see buildDirectMQTTConnectionWithCustomAuthorizer for implementation)
-            MqttClientConnection connection = cmdUtils.buildDirectMQTTConnectionWithCustomAuthorizer(callbacks);
+            /**
+             * Create the MQTT connection from the builder
+             */
+            AwsIotMqttConnectionBuilder builder = AwsIotMqttConnectionBuilder.newDefaultBuilder();
+            builder.withConnectionEventCallbacks(callbacks)
+                .withClientId(cmdData.input_clientId)
+                .withEndpoint(cmdData.input_endpoint)
+                .withCleanSession(true)
+                .withProtocolOperationTimeoutMs(60000);
+            builder.withCustomAuthorizer(
+                cmdData.input_customAuthUsername,
+                cmdData.input_customAuthorizerName,
+                cmdData.input_customAuthorizerSignature,
+                cmdData.input_customAuthPassword);
+            MqttClientConnection connection = builder.build();
+            builder.close();
+
+            /**
+             * Verify the connection was created
+             */
             if (connection == null)
             {
                 onApplicationFailure(new RuntimeException("MQTT connection creation (through custom authorizer) failed!"));
             }
 
-            // Connect and disconnect using the connection we created
-            // (see sampleConnectAndDisconnect for implementation)
-            cmdUtils.sampleConnectAndDisconnect(connection);
+            /**
+             * Connect and disconnect
+             */
+            CompletableFuture<Boolean> connected = connection.connect();
+            try {
+                boolean sessionPresent = connected.get();
+                System.out.println("Connected to " + (!sessionPresent ? "new" : "existing") + " session!");
+            } catch (Exception ex) {
+                throw new RuntimeException("Exception occurred during connect", ex);
+            }
+            System.out.println("Disconnecting...");
+            CompletableFuture<Void> disconnected = connection.disconnect();
+            disconnected.get();
+            System.out.println("Disconnected.");
 
             // Close the connection now that we are completely done with it.
             connection.close();
 
-        } catch (CrtRuntimeException | InterruptedException | ExecutionException ex) {
+        } catch (CrtRuntimeException | UnsupportedEncodingException | InterruptedException | ExecutionException ex) {
             onApplicationFailure(ex);
         }
 
diff --git a/samples/CustomKeyOpsPubSub/README.md b/samples/CustomKeyOpsConnect/README.md
similarity index 72%
rename from samples/CustomKeyOpsPubSub/README.md
rename to samples/CustomKeyOpsConnect/README.md
index 6cd4dafb2..6a591d6eb 100644
--- a/samples/CustomKeyOpsPubSub/README.md
+++ b/samples/CustomKeyOpsConnect/README.md
@@ -1,8 +1,8 @@
-# Custom Key Operations PubSub
+# Custom Key Operations Connect
 
 [**Return to main sample list**](../README.md)
 
-This sample is similar to the [Basic PubSub](../BasicPubSub/README.md) sample but shows how to perform custom private key operations during the Mutual TLS (mTLS) handshake. This is necessary if you require an external library to handle private key operations such as signing and decrypting. By utilizing custom private key operations, you can use any external library for the Mutual TLS private key operations when connecting to AWS IoT Core.
+This sample is similar to the [Basic Connect](../BasicConnect/README.md) sample but shows how to perform custom private key operations during the Mutual TLS (mTLS) handshake. This is necessary if you require an external library to handle private key operations such as signing and decrypting. By utilizing custom private key operations, you can use any external library for the Mutual TLS private key operations when connecting to AWS IoT Core.
 
 **WARNING: Unix (Linux) only**
 
@@ -56,16 +56,16 @@ Note that in a real application, you may want to avoid the use of wildcards in y
 
 ## How to run
 
-To run the Custom Key Ops PubSub sample use the following command:
+To run the Custom Key Ops Connect sample use the following command:
 
 ``` sh
-> mvn exec:java -pl samples/CustomKeyOpsPubSub -Dexec.mainClass=customkeyopspubsub.CustomKeyOpsPubSub -Dexec.args="--endpoint <endpoint> --cert <path to certificate> --key <path to pkcs8 key>"
+> mvn exec:java -pl samples/CustomKeyOpsConnect -Dexec.mainClass=customkeyopsconnect.CustomKeyOpsConnect -Dexec.args="--endpoint <endpoint> --cert <path to certificate> --key <path to pkcs8 key>"
 ```
 
 You can also pass a Certificate Authority file (CA) if your certificate and key combination requires it:
 
 ``` sh
-> mvn exec:java -pl samples/CustomKeyOpsPubSub -Dexec.mainClass=customkeyopspubsub.CustomKeyOpsPubSub -Dexec.args="--endpoint <endpoint> --cert <path to certificate> --key <path to pkcs8 key> --ca_file <path to root CA>"
+> mvn exec:java -pl samples/CustomKeyOpsConnect -Dexec.mainClass=customkeyopsconnect.CustomKeyOpsConnect -Dexec.args="--endpoint <endpoint> --cert <path to certificate> --key <path to pkcs8 key> --ca_file <path to root CA>"
 ```
 
 ### How to convert AWS IoT Core key to PCKS#8 key
diff --git a/samples/CustomKeyOpsPubSub/pom.xml b/samples/CustomKeyOpsConnect/pom.xml
similarity index 95%
rename from samples/CustomKeyOpsPubSub/pom.xml
rename to samples/CustomKeyOpsConnect/pom.xml
index 13b68db19..59dea22dc 100644
--- a/samples/CustomKeyOpsPubSub/pom.xml
+++ b/samples/CustomKeyOpsConnect/pom.xml
@@ -2,7 +2,7 @@
          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
     <modelVersion>4.0.0</modelVersion>
     <groupId>software.amazon.awssdk.iotdevicesdk</groupId>
-    <artifactId>CustomKeyOpsPubSub</artifactId>
+    <artifactId>CustomKeyOpsConnect</artifactId>
     <packaging>jar</packaging>
     <version>1.0-SNAPSHOT</version>
     <name>${project.groupId}:${project.artifactId}</name>
@@ -45,7 +45,7 @@
                 <artifactId>exec-maven-plugin</artifactId>
                 <version>1.4.0</version>
                 <configuration>
-                    <mainClass>customkeyopspubsub.CustomKeyOpsPubSub</mainClass>
+                    <mainClass>customkeyopsconnect.CustomKeyOpsConnect</mainClass>
                 </configuration>
             </plugin>
             <plugin>
diff --git a/samples/CustomKeyOpsPubSub/src/main/java/customkeyopspubsub/CustomKeyOpsPubSub.java b/samples/CustomKeyOpsConnect/src/main/java/customkeyopsconnect/CustomKeyOpsConnect.java
similarity index 75%
rename from samples/CustomKeyOpsPubSub/src/main/java/customkeyopspubsub/CustomKeyOpsPubSub.java
rename to samples/CustomKeyOpsConnect/src/main/java/customkeyopsconnect/CustomKeyOpsConnect.java
index c15fd5874..d7c6fe697 100644
--- a/samples/CustomKeyOpsPubSub/src/main/java/customkeyopspubsub/CustomKeyOpsPubSub.java
+++ b/samples/CustomKeyOpsConnect/src/main/java/customkeyopsconnect/CustomKeyOpsConnect.java
@@ -3,36 +3,31 @@
  * SPDX-License-Identifier: Apache-2.0.
  */
 
-package customkeyopspubsub;
+package customkeyopsconnect;
 
 import software.amazon.awssdk.crt.CRT;
 import software.amazon.awssdk.crt.CrtResource;
 import software.amazon.awssdk.crt.CrtRuntimeException;
 import software.amazon.awssdk.crt.io.*;
 import software.amazon.awssdk.crt.mqtt.*;
+import software.amazon.awssdk.crt.http.HttpProxyOptions;
 import software.amazon.awssdk.iot.AwsIotMqttConnectionBuilder;
 
-import software.amazon.awssdk.crt.Log;
-import software.amazon.awssdk.crt.Log.LogLevel;
-
 import java.io.BufferedReader;
 import java.io.ByteArrayOutputStream;
 import java.io.FileReader;
-import java.nio.charset.StandardCharsets;
 import java.security.KeyFactory;
 import java.security.PrivateKey;
 import java.security.Signature;
 import java.security.interfaces.RSAPrivateKey;
 import java.security.spec.PKCS8EncodedKeySpec;
 import java.util.Base64;
-import java.util.UUID;
 import java.util.concurrent.CompletableFuture;
-import java.util.concurrent.CountDownLatch;
 import java.util.concurrent.ExecutionException;
 
 import utils.commandlineutils.CommandLineUtils;
 
-public class CustomKeyOpsPubSub {
+public class CustomKeyOpsConnect {
 
     // When run normally, we want to exit nicely even if something goes wrong
     // When run from CI, we want to let an exception escape which in turn causes the
@@ -42,12 +37,6 @@ public class CustomKeyOpsPubSub {
 
     static CommandLineUtils cmdUtils;
 
-    static String topic = "test/topic";
-    static String message = "Hello World!";
-    static int    messagesToPublish = 10;
-    static String certPath;
-    static String keyPath;
-
     /*
      * When called during a CI run, throw an exception that will escape and fail the exec:java task
      * When called otherwise, print what went wrong (if anything) and just continue (return from main)
@@ -70,7 +59,7 @@ static class MyKeyOperationHandler implements TlsKeyOperationHandler {
         public void performOperation(TlsKeyOperation operation) {
             try {
                 System.out.println("MyKeyOperationHandler.performOperation" + operation.getType().name());
-                
+
                 if (operation.getType() != TlsKeyOperation.Type.SIGN) {
                     throw new RuntimeException("Simple sample only handles SIGN operations");
                 }
@@ -155,23 +144,12 @@ RSAPrivateKey loadPrivateKey(String filepath) {
 
     public static void main(String[] args) {
 
-        cmdUtils = new CommandLineUtils();
-        cmdUtils.registerProgramName("CustomKeyOpsPubSub");
-        cmdUtils.addCommonMQTTCommands();
-        cmdUtils.addCommonTopicMessageCommands();
-        cmdUtils.registerCommand("key", "<path>", "Path to your PKCS#8 key in PEM format.");
-        cmdUtils.registerCommand("cert", "<path>", "Path to your client certificate in PEM format.");
-        cmdUtils.registerCommand("client_id", "<int>", "Client id to use (optional, default='test-*').");
-        cmdUtils.registerCommand("port", "<int>", "Port to connect to on the endpoint (optional, default='8883').");
-        cmdUtils.registerCommand("count", "<int>", "Number of messages to publish (optional, default='10').");
-        cmdUtils.sendArguments(args);
-
-        keyPath = cmdUtils.getCommandRequired("key", "");
-        certPath = cmdUtils.getCommandRequired("cert", "");
-
-        topic = cmdUtils.getCommandOrDefault("topic", topic);
-        message = cmdUtils.getCommandOrDefault("message", message);
-        messagesToPublish = Integer.parseInt(cmdUtils.getCommandOrDefault("count", String.valueOf(messagesToPublish)));
+        /**
+         * cmdData is the arguments/input from the command line placed into a single struct for
+         * use in this sample. This handles all of the command line parsing, validating, etc.
+         * See the Utils/CommandLineUtils for more information.
+         */
+        CommandLineUtils.SampleCommandLineData cmdData = CommandLineUtils.getInputForIoTSample("CustomKeyOpsConnect", args);
 
         MqttClientConnectionEvents callbacks = new MqttClientConnectionEvents() {
             @Override
@@ -187,17 +165,45 @@ public void onConnectionResumed(boolean sessionPresent) {
             }
         };
 
-        MyKeyOperationHandler myKeyOperationHandler = new MyKeyOperationHandler(keyPath);
+        MyKeyOperationHandler myKeyOperationHandler = new MyKeyOperationHandler(cmdData.input_key);
         TlsContextCustomKeyOperationOptions keyOperationOptions = new TlsContextCustomKeyOperationOptions(myKeyOperationHandler)
-                .withCertificateFilePath(certPath);
+                .withCertificateFilePath(cmdData.input_cert);
 
         try {
-            MqttClientConnection connection = cmdUtils.buildCustomKeyOperationConnection(callbacks, keyOperationOptions);
+
+            /**
+             * Create the MQTT connection from the builder
+             */
+            AwsIotMqttConnectionBuilder builder = AwsIotMqttConnectionBuilder.newMtlsCustomKeyOperationsBuilder(keyOperationOptions);
+            if (cmdData.input_ca != "") {
+                builder.withCertificateAuthorityFromPath(null, cmdData.input_ca);
+            }
+            builder.withConnectionEventCallbacks(callbacks)
+                .withClientId(cmdData.input_clientId)
+                .withEndpoint(cmdData.input_endpoint)
+                .withPort((short)cmdData.input_port)
+                .withCleanSession(true)
+                .withProtocolOperationTimeoutMs(60000);
+            if (cmdData.input_proxyHost != "" && cmdData.input_proxyPort > 0) {
+                HttpProxyOptions proxyOptions = new HttpProxyOptions();
+                proxyOptions.setHost(cmdData.input_proxyHost);
+                proxyOptions.setPort(cmdData.input_proxyPort);
+                builder.withHttpProxyOptions(proxyOptions);
+            }
+            MqttClientConnection connection = builder.build();
+            builder.close();
+
+            /**
+             * Verify the connection was created
+             */
             if (connection == null)
             {
                 onApplicationFailure(new RuntimeException("MQTT connection creation failed!"));
             }
 
+            /**
+             * Connect and disconnect
+             */
             CompletableFuture<Boolean> connected = connection.connect();
             try {
                 boolean sessionPresent = connected.get();
@@ -205,29 +211,14 @@ public void onConnectionResumed(boolean sessionPresent) {
             } catch (Exception ex) {
                 throw new RuntimeException("Exception occurred during connect", ex);
             }
-
-            CountDownLatch countDownLatch = new CountDownLatch(messagesToPublish);
-
-            CompletableFuture<Integer> subscribed = connection.subscribe(topic, QualityOfService.AT_LEAST_ONCE, (message) -> {
-                String payload = new String(message.getPayload(), StandardCharsets.UTF_8);
-                System.out.println("MESSAGE: " + payload);
-                countDownLatch.countDown();
-            });
-
-            subscribed.get();
-
-            int count = 0;
-            while (count++ < messagesToPublish) {
-                CompletableFuture<Integer> published = connection.publish(new MqttMessage(topic, message.getBytes(), QualityOfService.AT_LEAST_ONCE, false));
-                published.get();
-                Thread.sleep(1000);
-            }
-
-            countDownLatch.await();
-
+            System.out.println("Disconnecting...");
             CompletableFuture<Void> disconnected = connection.disconnect();
             disconnected.get();
+            System.out.println("Disconnected.");
 
+            /**
+             * Close the connection now that it is complete
+             */
             connection.close();
 
         } catch (CrtRuntimeException | InterruptedException | ExecutionException ex) {
diff --git a/samples/Identity/README.md b/samples/FleetProvisioning/README.md
similarity index 93%
rename from samples/Identity/README.md
rename to samples/FleetProvisioning/README.md
index 20e754936..55fb5eb71 100644
--- a/samples/Identity/README.md
+++ b/samples/FleetProvisioning/README.md
@@ -2,7 +2,7 @@
 
 [**Return to main sample list**](../README.md)
 
-This sample uses the AWS IoT [Fleet provisioning](https://docs.aws.amazon.com/iot/latest/developerguide/provision-wo-cert.html) to provision devices using either a CSR or Keys-And-Certificate and subsequently calls RegisterThing. This allows you to create new AWS IoT Core things using a Fleet Provisioning Template.
+This sample uses the AWS IoT [Fleet-Provisioning/Identity](https://docs.aws.amazon.com/iot/latest/developerguide/provision-wo-cert.html) service to provision devices using either a CSR or Keys-And-Certificate and subsequently calls RegisterThing. This allows you to create new AWS IoT Core things using a Fleet Provisioning Template.
 
 On startup, the script subscribes to topics based on the request type of either CSR or Keys topics, publishes the request to corresponding topic and calls RegisterThing.
 
@@ -74,14 +74,14 @@ Note that in a real application, you may want to avoid the use of wildcards in y
 There are many different ways to run the Fleet Provisioning sample because of how many different ways there are to setup a Fleet Provisioning template in AWS IoT Core. **The easiest and most common way is to run the sample with the following**:
 
 ``` sh
-mvn compile exec:java -pl samples/Identity -Dexec.mainClass="identity.FleetProvisioningSample" -Dexec.args="--endpoint <endpoint>
+mvn compile exec:java -pl samples/FleetProvisioning -Dexec.mainClass="fleetprovisioning.FleetProvisioningSample" -Dexec.args="--endpoint <endpoint>
 --cert <path to certificate> --key <path to private key> --template_name <template name> --template_parameters <template params>"
 ```
 
 You can also pass a Certificate Authority file (CA) if your certificate and key combination requires it:
 
 ``` sh
-mvn compile exec:java -pl samples/Identity -Dexec.mainClass="identity.FleetProvisioningSample" -Dexec.args="--endpoint <endpoint> --ca_file <path to root CA>
+mvn compile exec:java -pl samples/FleetProvisioning -Dexec.mainClass="fleetprovisioning.FleetProvisioningSample" -Dexec.args="--endpoint <endpoint> --ca_file <path to root CA>
 --cert <path to certificate> --key <path to private key> --template_name <template name> --template_parameters <template params>"
 ```
 
@@ -251,7 +251,7 @@ We've included a script in the utils folder that creates certificate and key fil
 `create-provisioning-claim`. These dynamically sourced certificates are **only valid for five minutes**. When running the command,
 you'll need to substitute the name of the template you previously created. If on Windows, replace the paths with something appropriate.
 
-**Note**: The following assumes you are running this command from the `aws-iot-device-sdk-java-v2` folder, which is the main GitHub folder. If you are running this from another folder (like the `samples/Identity` folder), then you will need to adjust the filepaths accordingly.
+**Note**: The following assumes you are running this command from the `aws-iot-device-sdk-java-v2` folder, which is the main GitHub folder. If you are running this from another folder (like the `samples/FleetProvisioning` folder), then you will need to adjust the filepaths accordingly.
 
 ```sh
 aws iot create-provisioning-claim \
@@ -270,7 +270,7 @@ to perform the actual provisioning in the section below.
 To run the sample with your certificate and private key, use the following command:
 
 ``` sh
-mvn compile exec:java -pl samples/Identity -Dexec.mainClass="identity.FleetProvisioningSample" -Dexec.args="--endpoint <endpoint>
+mvn compile exec:java -pl samples/FleetProvisioning -Dexec.mainClass="fleetprovisioning.FleetProvisioningSample" -Dexec.args="--endpoint <endpoint>
 --cert <path to certificate> --key <path to private key> --template_name <template name> --template_parameters '{\"SerialNumber\":\"1\",\"DeviceLocation\":\"Seattle\"}'"
 ```
 
@@ -306,7 +306,7 @@ aws iot create-provisioning-claim \
 Finally, you can also pass the certificate signing request while invoking the Fleet Provisioning sample.
 
 ``` sh
-mvn compile exec:java -pl samples/Identity -Dexec.mainClass="identity.FleetProvisioningSample" -Dexec.args="--endpoint <endpoint>
+mvn compile exec:java -pl samples/FleetProvisioning -Dexec.mainClass="fleetprovisioning.FleetProvisioningSample" -Dexec.args="--endpoint <endpoint>
 --cert <path to certificate> --key <path to private key> --template_name <template name> --template_parameters '{\"SerialNumber\":\"1\",\"DeviceLocation\":\"Seattle\"}'  --csr <path to csr file>"
 ```
 
diff --git a/samples/Identity/pom.xml b/samples/FleetProvisioning/pom.xml
similarity index 98%
rename from samples/Identity/pom.xml
rename to samples/FleetProvisioning/pom.xml
index 72933264a..c497a74fc 100644
--- a/samples/Identity/pom.xml
+++ b/samples/FleetProvisioning/pom.xml
@@ -2,7 +2,7 @@
          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
     <modelVersion>4.0.0</modelVersion>
     <groupId>software.amazon.awssdk.iotdevicesdk</groupId>
-    <artifactId>Identity</artifactId>
+    <artifactId>FleetProvisioning</artifactId>
     <packaging>jar</packaging>
     <version>1.0-SNAPSHOT</version>
     <name>${project.groupId}:${project.artifactId}</name>
diff --git a/samples/Identity/src/main/java/identity/FleetProvisioningSample.java b/samples/FleetProvisioning/src/main/java/fleetprovisioning/FleetProvisioningSample.java
similarity index 77%
rename from samples/Identity/src/main/java/identity/FleetProvisioningSample.java
rename to samples/FleetProvisioning/src/main/java/fleetprovisioning/FleetProvisioningSample.java
index 7e1f79fcb..574245d62 100644
--- a/samples/Identity/src/main/java/identity/FleetProvisioningSample.java
+++ b/samples/FleetProvisioning/src/main/java/fleetprovisioning/FleetProvisioningSample.java
@@ -3,12 +3,11 @@
  * SPDX-License-Identifier: Apache-2.0.
  */
 
-package identity;
+package fleetprovisioning;
 
 import software.amazon.awssdk.crt.CRT;
 import software.amazon.awssdk.crt.CrtResource;
 import software.amazon.awssdk.crt.CrtRuntimeException;
-import software.amazon.awssdk.crt.Log;
 import software.amazon.awssdk.crt.mqtt.MqttClientConnection;
 import software.amazon.awssdk.crt.mqtt.MqttClientConnectionEvents;
 import software.amazon.awssdk.crt.mqtt.QualityOfService;
@@ -30,18 +29,18 @@
 
 import java.util.HashMap;
 import com.google.gson.Gson;
-import java.util.UUID;
 import java.util.concurrent.CompletableFuture;
-import java.util.concurrent.ExecutionException;
 import java.util.concurrent.TimeUnit;
-import java.util.concurrent.TimeoutException;
 
 import utils.commandlineutils.CommandLineUtils;
 
 public class FleetProvisioningSample {
-    static String templateName;
-    static String templateParameters;
-    static String csrPath;
+
+    // When run normally, we want to exit nicely even if something goes wrong.
+    // When run from CI, we want to let an exception escape which in turn causes the
+    // exec:java task to return a non-zero exit code.
+    static String ciPropValue = System.getProperty("aws.crt.ci");
+    static boolean isCI = ciPropValue != null && Boolean.valueOf(ciPropValue);
 
     static CompletableFuture<Void> gotResponse;
     static IotIdentityClient iotIdentityClient;
@@ -54,6 +53,18 @@ public class FleetProvisioningSample {
 
     static CommandLineUtils cmdUtils;
 
+    /*
+     * When called during a CI run, throw an exception that will escape and fail the exec:java task
+     * When called otherwise, print what went wrong (if anything) and just continue (return from main)
+     */
+    static void onApplicationFailure(Throwable cause) {
+        if (isCI) {
+            throw new RuntimeException("BasicConnect execution failure", cause);
+        } else if (cause != null) {
+            System.out.println("Exception encountered: " + cause.toString());
+        }
+    }
+
     static void onRejectedKeys(ErrorResponse response) {
         System.out.println("CreateKeysAndCertificate Request rejected, errorCode: " + response.errorCode +
                 ", errorMessage: " + response.errorMessage +
@@ -128,21 +139,12 @@ static void onException(Exception e) {
 
     public static void main(String[] args) {
 
-        cmdUtils = new CommandLineUtils();
-        cmdUtils.registerProgramName("FleetProvisioningSample");
-        cmdUtils.addCommonMQTTCommands();
-        cmdUtils.registerCommand("key", "<path>", "Path to your key in PEM format.");
-        cmdUtils.registerCommand("cert", "<path>", "Path to your client certificate in PEM format.");
-        cmdUtils.registerCommand("client_id", "<int>", "Client id to use (optional, default='test-*').");
-        cmdUtils.registerCommand("port", "<int>", "Port to connect to on the endpoint (optional, default='8883').");
-        cmdUtils.registerCommand("template_name", "<str>", "Provisioning template name.");
-        cmdUtils.registerCommand("template_parameters", "<json>", "Provisioning template parameters.");
-        cmdUtils.registerCommand("csr", "<path>", "Path to the CSR file (optional).");
-        cmdUtils.sendArguments(args);
-
-        templateName = cmdUtils.getCommandRequired("template_name", "");
-        templateParameters = cmdUtils.getCommandRequired("template_parameters", "");
-        csrPath = cmdUtils.getCommandOrDefault("csr", csrPath);
+        /**
+         * cmdData is the arguments/input from the command line placed into a single struct for
+         * use in this sample. This handles all of the command line parsing, validating, etc.
+         * See the Utils/CommandLineUtils for more information.
+         */
+        CommandLineUtils.SampleCommandLineData cmdData = CommandLineUtils.getInputForIoTSample("FleetProvisioningSample", args);
 
         MqttClientConnectionEvents callbacks = new MqttClientConnectionEvents() {
             @Override
@@ -162,19 +164,46 @@ public void onConnectionResumed(boolean sessionPresent) {
         boolean exitWithError = false;
 
         try {
-            connection = cmdUtils.buildMQTTConnection(callbacks);
+            /**
+             * Create the MQTT connection from the builder
+             */
+            AwsIotMqttConnectionBuilder builder = AwsIotMqttConnectionBuilder.newMtlsBuilderFromPath(cmdData.input_cert, cmdData.input_key);
+            if (cmdData.input_ca != "") {
+                builder.withCertificateAuthorityFromPath(null, cmdData.input_ca);
+            }
+            builder.withConnectionEventCallbacks(callbacks)
+                .withClientId(cmdData.input_clientId)
+                .withEndpoint(cmdData.input_endpoint)
+                .withPort((short)cmdData.input_port)
+                .withCleanSession(true)
+                .withProtocolOperationTimeoutMs(60000);
+            connection = builder.build();
+            builder.close();
+
+            /**
+             * Verify the connection was created
+             */
+            if (connection == null)
+            {
+                onApplicationFailure(new RuntimeException("MQTT connection creation failed!"));
+            }
+
+            // Create the identity client (Identity = Fleet Provisioning)
             iotIdentityClient = new IotIdentityClient(connection);
 
+            // Connect
             CompletableFuture<Boolean> connected = connection.connect();
             boolean sessionPresent = connected.get(responseWaitTimeMs, TimeUnit.MILLISECONDS);
             System.out.println("Connected to " + (!sessionPresent ? "new" : "existing") + " session!");
 
-            if (csrPath == null) {
-                createKeysAndCertificateWorkflow();
+            // Fleet Provision based on whether there is a CSR file path or not
+            if (cmdData.input_csrPath == null) {
+                createKeysAndCertificateWorkflow(cmdData.input_templateName, cmdData.input_templateParameters);
             } else {
-                createCertificateFromCsrWorkflow();
+                createCertificateFromCsrWorkflow(cmdData.input_templateName, cmdData.input_templateParameters, cmdData.input_csrPath);
             }
 
+            // Disconnect
             CompletableFuture<Void> disconnected = connection.disconnect();
             disconnected.get(responseWaitTimeMs, TimeUnit.MILLISECONDS);
 
@@ -182,11 +211,11 @@ public void onConnectionResumed(boolean sessionPresent) {
             System.out.println("Exception encountered! " + "\n");
             ex.printStackTrace();
             exitWithError = true;
-        }
-
-        if (connection != null) {
-            // Close the connection now that we are completely done with it.
-            connection.close();
+        } finally {
+            if (connection != null) {
+                // Close the connection now that we are completely done with it.
+                connection.close();
+            }
         }
 
         CrtResource.waitForNoResources();
@@ -199,9 +228,9 @@ public void onConnectionResumed(boolean sessionPresent) {
         }
     }
 
-    private static void SubscribeToRegisterThing() throws Exception {
+    private static void SubscribeToRegisterThing(String input_templateName) throws Exception {
         RegisterThingSubscriptionRequest registerThingSubscriptionRequest = new RegisterThingSubscriptionRequest();
-        registerThingSubscriptionRequest.templateName = templateName;
+        registerThingSubscriptionRequest.templateName = input_templateName;
 
         CompletableFuture<Integer> subscribedRegisterAccepted = iotIdentityClient.SubscribeToRegisterThingAccepted(
                 registerThingSubscriptionRequest,
@@ -222,7 +251,7 @@ private static void SubscribeToRegisterThing() throws Exception {
         System.out.println("Subscribed to SubscribeToRegisterThingRejected");
     }
 
-    private static void createKeysAndCertificateWorkflow() throws Exception {
+    private static void createKeysAndCertificateWorkflow(String input_templateName, String input_templateParameters) throws Exception {
         CreateKeysAndCertificateSubscriptionRequest createKeysAndCertificateSubscriptionRequest = new CreateKeysAndCertificateSubscriptionRequest();
         CompletableFuture<Integer> keysSubscribedAccepted = iotIdentityClient.SubscribeToCreateKeysAndCertificateAccepted(
                 createKeysAndCertificateSubscriptionRequest,
@@ -241,7 +270,7 @@ private static void createKeysAndCertificateWorkflow() throws Exception {
         System.out.println("Subscribed to CreateKeysAndCertificateRejected");
 
         // Subscribes to the register thing accepted and rejected topics
-        SubscribeToRegisterThing();
+        SubscribeToRegisterThing(input_templateName);
 
         CompletableFuture<Integer> publishKeys = iotIdentityClient.PublishCreateKeysAndCertificate(
                 new CreateKeysAndCertificateRequest(),
@@ -262,10 +291,10 @@ private static void createKeysAndCertificateWorkflow() throws Exception {
         System.out.println("RegisterThing now....");
         RegisterThingRequest registerThingRequest = new RegisterThingRequest();
         registerThingRequest.certificateOwnershipToken = createKeysAndCertificateResponse.certificateOwnershipToken;
-        registerThingRequest.templateName = templateName;
+        registerThingRequest.templateName = input_templateName;
 
-        if (templateParameters != null && templateParameters != "") {
-            registerThingRequest.parameters = new Gson().fromJson(templateParameters, HashMap.class);
+        if (input_templateParameters != null && input_templateParameters != "") {
+            registerThingRequest.parameters = new Gson().fromJson(input_templateParameters, HashMap.class);
         }
 
         CompletableFuture<Integer> publishRegister = iotIdentityClient.PublishRegisterThing(
@@ -278,7 +307,7 @@ private static void createKeysAndCertificateWorkflow() throws Exception {
         System.out.println("Got response at RegisterThing");
     }
 
-    private static void createCertificateFromCsrWorkflow() throws Exception {
+    private static void createCertificateFromCsrWorkflow(String input_templateName, String input_templateParameters, String input_csrPath) throws Exception {
         CreateCertificateFromCsrSubscriptionRequest createCertificateFromCsrSubscriptionRequest = new CreateCertificateFromCsrSubscriptionRequest();
         CompletableFuture<Integer> csrSubscribedAccepted = iotIdentityClient.SubscribeToCreateCertificateFromCsrAccepted(
                 createCertificateFromCsrSubscriptionRequest,
@@ -297,9 +326,9 @@ private static void createCertificateFromCsrWorkflow() throws Exception {
         System.out.println("Subscribed to CreateCertificateFromCsrRejected");
 
         // Subscribes to the register thing accepted and rejected topics
-        SubscribeToRegisterThing();
+        SubscribeToRegisterThing(input_templateName);
 
-        String csrContents = new String(Files.readAllBytes(Paths.get(csrPath)));
+        String csrContents = new String(Files.readAllBytes(Paths.get(input_csrPath)));
         CreateCertificateFromCsrRequest createCertificateFromCsrRequest = new CreateCertificateFromCsrRequest();
         createCertificateFromCsrRequest.certificateSigningRequest = csrContents;
         CompletableFuture<Integer> publishCsr = iotIdentityClient.PublishCreateCertificateFromCsr(
@@ -321,8 +350,8 @@ private static void createCertificateFromCsrWorkflow() throws Exception {
         System.out.println("RegisterThing now....");
         RegisterThingRequest registerThingRequest = new RegisterThingRequest();
         registerThingRequest.certificateOwnershipToken = createCertificateFromCsrResponse.certificateOwnershipToken;
-        registerThingRequest.templateName = templateName;
-        registerThingRequest.parameters = new Gson().fromJson(templateParameters, HashMap.class);
+        registerThingRequest.templateName = input_templateName;
+        registerThingRequest.parameters = new Gson().fromJson(input_templateParameters, HashMap.class);
         CompletableFuture<Integer> publishRegister = iotIdentityClient.PublishRegisterThing(
                 registerThingRequest,
                 QualityOfService.AT_LEAST_ONCE);
diff --git a/samples/Greengrass/src/main/java/greengrass/BasicDiscovery.java b/samples/Greengrass/src/main/java/greengrass/BasicDiscovery.java
index 2f62392a0..d93193631 100644
--- a/samples/Greengrass/src/main/java/greengrass/BasicDiscovery.java
+++ b/samples/Greengrass/src/main/java/greengrass/BasicDiscovery.java
@@ -7,7 +7,6 @@
 
 import software.amazon.awssdk.crt.CrtResource;
 import software.amazon.awssdk.crt.CrtRuntimeException;
-import software.amazon.awssdk.crt.Log;
 import software.amazon.awssdk.crt.http.HttpProxyOptions;
 import software.amazon.awssdk.crt.io.*;
 import software.amazon.awssdk.crt.mqtt.*;
@@ -30,91 +29,69 @@
 import utils.commandlineutils.CommandLineUtils;
 
 public class BasicDiscovery {
-    static String thingName;
-    static String rootCaPath;
-    static String certPath;
-    static String keyPath;
-    static String region = "us-east-1";
-    static String topic = "test/topic";
-    static String mode = "both";
 
-    static String proxyHost;
-    static int proxyPort;
+    static String input_thingName;
+    static String input_certPath;
+    static String input_keyPath;
 
     static CommandLineUtils cmdUtils;
 
     public static void main(String[] args) {
-        cmdUtils = new CommandLineUtils();
-        cmdUtils.registerProgramName("BasicDiscovery");
-        cmdUtils.addCommonMQTTCommands();
-        cmdUtils.removeCommand("endpoint");
-        cmdUtils.registerCommand("thing_name", "<str>", "The name of the IoT thing.");
-        cmdUtils.registerCommand("region", "<str>", "AWS IoT service region (optional, default='us-east-1').");
-        cmdUtils.registerCommand("topic", "<str>", "Topic to subscribe/publish to (optional, default='test/topic').");
-        cmdUtils.registerCommand("mode", "<str>", "Mode options: 'both', 'publish', or 'subscribe' (optional, default='both').");
-        cmdUtils.registerCommand("proxy_host", "<str>", "Websocket proxy host to use (optional, required if --proxy_port is set).");
-        cmdUtils.registerCommand("proxy_port", "<int>", "Websocket proxy port to use (optional, required if --proxy_host is set).");
-        cmdUtils.registerCommand("help", "", "Prints this message");
-        cmdUtils.sendArguments(args);
-
-        if (cmdUtils.hasCommand("help")) {
-            cmdUtils.printHelp();
-            System.exit(1);
-        }
 
-        thingName = cmdUtils.getCommandRequired("thing_name", "");
-        region = cmdUtils.getCommandOrDefault("region", region);
-        rootCaPath = cmdUtils.getCommandOrDefault("ca_file", rootCaPath);
-        certPath = cmdUtils.getCommandRequired("cert", "");
-        keyPath = cmdUtils.getCommandRequired("key", "");
-        topic = cmdUtils.getCommandOrDefault("topic", topic);
-        mode = cmdUtils.getCommandOrDefault("mode", mode);
-        proxyHost = cmdUtils.getCommandOrDefault("proxy_host", proxyHost);
-        proxyPort = Integer.parseInt(cmdUtils.getCommandOrDefault("proxy_port", String.valueOf(proxyPort)));
+        /**
+         * cmdData is the arguments/input from the command line placed into a single struct for
+         * use in this sample. This handles all of the command line parsing, validating, etc.
+         * See the Utils/CommandLineUtils for more information.
+         */
+        CommandLineUtils.SampleCommandLineData cmdData = CommandLineUtils.getInputForIoTSample("BasicDiscovery", args);
+
+        input_thingName = cmdData.input_thingName;
+        input_certPath = cmdData.input_cert;
+        input_keyPath = cmdData.input_key;
 
         // ---- Verify file loads ----
         // Get the absolute CA file path
-        final File rootCaFile = new File(rootCaPath);
+        final File rootCaFile = new File(cmdData.input_ca);
         if (!rootCaFile.isFile()) {
             throw new RuntimeException("Cannot load root CA from path: " + rootCaFile.getAbsolutePath());
         }
-        rootCaPath = rootCaFile.getAbsolutePath();
+        cmdData.input_ca = rootCaFile.getAbsolutePath();
 
-        final File certFile = new File(certPath);
+        final File certFile = new File(cmdData.input_cert);
         if (!certFile.isFile()) {
             throw new RuntimeException("Cannot load certificate from path: " + certFile.getAbsolutePath());
         }
-        certPath = certFile.getAbsolutePath();
+        cmdData.input_cert = certFile.getAbsolutePath();
 
-        final File keyFile = new File(keyPath);
+        final File keyFile = new File(cmdData.input_key);
         if (!keyFile.isFile()) {
             throw new RuntimeException("Cannot load private key from path: " + keyFile.getAbsolutePath());
         }
-        keyPath = keyFile.getAbsolutePath();
+        cmdData.input_key = keyFile.getAbsolutePath();
         // ----------------------------
 
-        try(final TlsContextOptions tlsCtxOptions = TlsContextOptions.createWithMtlsFromPath(certPath, keyPath)) {
+        try(final TlsContextOptions tlsCtxOptions = TlsContextOptions.createWithMtlsFromPath(cmdData.input_cert, cmdData.input_key)) {
             if(TlsContextOptions.isAlpnSupported()) {
                 tlsCtxOptions.withAlpnList(TLS_EXT_ALPN);
             }
-            if(rootCaPath != null) {
-                tlsCtxOptions.overrideDefaultTrustStoreFromPath(null, rootCaPath);
+            if(cmdData.input_ca != null) {
+                tlsCtxOptions.overrideDefaultTrustStoreFromPath(null, cmdData.input_ca);
             }
             HttpProxyOptions proxyOptions = null;
-            if (proxyHost != null && proxyPort > 0) {
+            if (cmdData.input_proxyHost != null && cmdData.input_proxyPort > 0) {
                 proxyOptions = new HttpProxyOptions();
-                proxyOptions.setHost(proxyHost);
-                proxyOptions.setPort(proxyPort);
+                proxyOptions.setHost(cmdData.input_proxyHost);
+                proxyOptions.setPort(cmdData.input_proxyPort);
             }
 
             try(final DiscoveryClientConfig discoveryClientConfig =
                         new DiscoveryClientConfig(tlsCtxOptions,
-                        new SocketOptions(), region, 1, proxyOptions);
+                        new SocketOptions(), cmdData.input_signingRegion, 1, proxyOptions);
                 final DiscoveryClient discoveryClient = new DiscoveryClient(discoveryClientConfig);
                 final MqttClientConnection connection = getClientFromDiscovery(discoveryClient)) {
 
-                if ("subscribe".equals(mode) || "both".equals(mode)) {
-                    final CompletableFuture<Integer> subFuture = connection.subscribe(topic, QualityOfService.AT_MOST_ONCE, message -> {
+                if ("subscribe".equals(cmdData.input_mode) || "both".equals(cmdData.input_mode)) {
+                    final CompletableFuture<Integer> subFuture = connection.subscribe(cmdData.input_topic, QualityOfService.AT_MOST_ONCE, message -> {
                         System.out.println(String.format("Message received on topic %s: %s",
                                 message.getTopic(), new String(message.getPayload(), StandardCharsets.UTF_8)));
                     });
@@ -125,8 +102,8 @@ public static void main(String[] args) {
                 final Scanner scanner = new Scanner(System.in);
                 while (true) {
                     String input = null;
-                    if ("publish".equals(mode) || "both".equals(mode)) {
-                        System.out.println("Enter the message you want to publish to topic " + topic + " and press Enter. " +
+                    if ("publish".equals(cmdData.input_mode) || "both".equals(cmdData.input_mode)) {
+                        System.out.println("Enter the message you want to publish to topic " + cmdData.input_topic + " and press Enter. " +
                                 "Type 'exit' or 'quit' to exit this program: ");
                         input = scanner.nextLine();
                     }
@@ -136,8 +113,8 @@ public static void main(String[] args) {
                         break;
                     }
 
-                    if ("publish".equals(mode) || "both".equals(mode)) {
-                        final CompletableFuture<Integer> publishResult = connection.publish(new MqttMessage(topic,
+                    if ("publish".equals(cmdData.input_mode) || "both".equals(cmdData.input_mode)) {
+                        final CompletableFuture<Integer> publishResult = connection.publish(new MqttMessage(cmdData.input_topic,
                                 input.getBytes(StandardCharsets.UTF_8), QualityOfService.AT_MOST_ONCE, false));
                         Integer result = publishResult.get();
                     }
@@ -153,7 +130,7 @@ public static void main(String[] args) {
 
     private static MqttClientConnection getClientFromDiscovery(final DiscoveryClient discoveryClient
                                                                ) throws ExecutionException, InterruptedException {
-        final CompletableFuture<DiscoverResponse> futureResponse = discoveryClient.discover(thingName);
+        final CompletableFuture<DiscoverResponse> futureResponse = discoveryClient.discover(input_thingName);
         final DiscoverResponse response = futureResponse.get();
         if(response.getGGGroups() != null) {
             final Optional<GGGroup> groupOpt = response.getGGGroups().stream().findFirst();
@@ -168,8 +145,8 @@ private static MqttClientConnection getClientFromDiscovery(final DiscoveryClient
                     System.out.println(String.format("Connecting to group ID %s, with thing arn %s, using endpoint %s:%d",
                             group.getGGGroupId(), core.getThingArn(), dnsOrIp, port));
 
-                    final AwsIotMqttConnectionBuilder connectionBuilder = AwsIotMqttConnectionBuilder.newMtlsBuilderFromPath(certPath, keyPath)
-                            .withClientId(thingName)
+                    final AwsIotMqttConnectionBuilder connectionBuilder = AwsIotMqttConnectionBuilder.newMtlsBuilderFromPath(input_certPath, input_keyPath)
+                            .withClientId(input_thingName)
                             .withPort(port.shortValue())
                             .withEndpoint(dnsOrIp)
                             .withConnectionEventCallbacks(new MqttClientConnectionEvents() {
@@ -203,9 +180,9 @@ public void onConnectionResumed(boolean sessionPresent) {
                     }
                 }
 
-                throw new RuntimeException("ThingName " + thingName + " could not connect to the green grass core using any of the endpoint connectivity options");
+                throw new RuntimeException("ThingName " + input_thingName + " could not connect to the green grass core using any of the endpoint connectivity options");
             }
         }
-        throw new RuntimeException("ThingName " + thingName + " does not have a Greengrass group/core configuration");
+        throw new RuntimeException("ThingName " + input_thingName + " does not have a Greengrass group/core configuration");
     }
 }
diff --git a/samples/JavaKeystoreConnect/src/main/java/javakeystoreconnect/JavaKeystoreConnect.java b/samples/JavaKeystoreConnect/src/main/java/javakeystoreconnect/JavaKeystoreConnect.java
index a137f1b0f..c8ad467d0 100644
--- a/samples/JavaKeystoreConnect/src/main/java/javakeystoreconnect/JavaKeystoreConnect.java
+++ b/samples/JavaKeystoreConnect/src/main/java/javakeystoreconnect/JavaKeystoreConnect.java
@@ -8,12 +8,13 @@
 import software.amazon.awssdk.crt.CRT;
 import software.amazon.awssdk.crt.CrtResource;
 import software.amazon.awssdk.crt.CrtRuntimeException;
-import software.amazon.awssdk.crt.io.ClientBootstrap;
 import software.amazon.awssdk.crt.mqtt.MqttClientConnection;
 import software.amazon.awssdk.crt.mqtt.MqttClientConnectionEvents;
-import software.amazon.awssdk.iot.iotjobs.model.RejectedError;
+import software.amazon.awssdk.crt.http.HttpProxyOptions;
+import software.amazon.awssdk.iot.AwsIotMqttConnectionBuilder;
 
 import java.util.concurrent.ExecutionException;
+import java.util.concurrent.CompletableFuture;
 
 import utils.commandlineutils.CommandLineUtils;
 
@@ -27,10 +28,6 @@ public class JavaKeystoreConnect {
 
     static CommandLineUtils cmdUtils;
 
-    static void onRejectedError(RejectedError error) {
-        System.out.println("Request rejected: " + error.code.toString() + ": " + error.message);
-    }
-
     /*
      * When called during a CI run, throw an exception that will escape and fail the exec:java task
      * When called otherwise, print what went wrong (if anything) and just continue (return from main)
@@ -45,18 +42,12 @@ static void onApplicationFailure(Throwable cause) {
 
     public static void main(String[] args) {
 
-        cmdUtils = new CommandLineUtils();
-        cmdUtils.registerProgramName("JavaKeystoreConnect");
-        cmdUtils.addCommonMQTTCommands();
-        cmdUtils.addCommonProxyCommands();
-        cmdUtils.registerCommand("keystore", "<file>", "The path to the Java keystore to use");
-        cmdUtils.registerCommand("keystore_password", "<str>", "The password for the Java keystore");
-        cmdUtils.registerCommand("keystore_format", "<str>", "The format of the Java keystore (optional, default='PKCS12')");
-        cmdUtils.registerCommand("certificate_alias", "<str>", "The certificate alias to use to access the key and certificate in the Java keystore");
-        cmdUtils.registerCommand("certificate_password", "<str>", "The password associated with the key and certificate in the Java keystore");
-        cmdUtils.registerCommand("client_id", "<int>", "Client id to use (optional, default='test-*').");
-        cmdUtils.registerCommand("port", "<int>", "Port to connect to on the endpoint (optional, default='8883').");
-        cmdUtils.sendArguments(args);
+        /**
+         * cmdData is the arguments/input from the command line placed into a single struct for
+         * use in this sample. This handles all of the command line parsing, validating, etc.
+         * See the Utils/CommandLineUtils for more information.
+         */
+        CommandLineUtils.SampleCommandLineData cmdData = CommandLineUtils.getInputForIoTSample("JavaKeystoreConnect", args);
 
         MqttClientConnectionEvents callbacks = new MqttClientConnectionEvents() {
             @Override
@@ -74,20 +65,70 @@ public void onConnectionResumed(boolean sessionPresent) {
 
         try {
 
-            // Create a connection using a certificate and key stored in the Java keystore
-            // Note: The data for the connection is gotten from cmdUtils.
-            // (see buildDirectMQTTConnectionWithJavaKeystore for implementation)
-            MqttClientConnection connection = cmdUtils.buildDirectMQTTConnectionWithJavaKeystore(callbacks);
+            /**
+             * Create the MQTT connection from the builder
+             */
+            java.security.KeyStore keyStore;
+            try {
+                keyStore = java.security.KeyStore.getInstance(cmdData.input_keystoreFormat);
+            } catch (java.security.KeyStoreException ex) {
+                throw new CrtRuntimeException("Could not get instance of Java keystore with format " + cmdData.input_keystoreFormat);
+            }
+            try (java.io.FileInputStream fileInputStream = new java.io.FileInputStream(cmdData.input_keystore)) {
+                keyStore.load(fileInputStream, cmdData.input_keystorePassword.toCharArray());
+            } catch (java.io.FileNotFoundException ex) {
+                throw new CrtRuntimeException("Could not open Java keystore file");
+            } catch (java.io.IOException | java.security.NoSuchAlgorithmException | java.security.cert.CertificateException ex) {
+                throw new CrtRuntimeException("Could not load Java keystore");
+            }
+            AwsIotMqttConnectionBuilder builder = AwsIotMqttConnectionBuilder.newJavaKeystoreBuilder(
+                keyStore,
+                cmdData.input_certificateAlias,
+                cmdData.input_certificatePassword);
+            if (cmdData.input_ca != "") {
+                builder.withCertificateAuthorityFromPath(null, cmdData.input_ca);
+            }
+            builder.withConnectionEventCallbacks(callbacks)
+                .withClientId(cmdData.input_clientId)
+                .withEndpoint(cmdData.input_endpoint)
+                .withPort((short)cmdData.input_port)
+                .withCleanSession(true)
+                .withProtocolOperationTimeoutMs(60000);
+            if (cmdData.input_proxyHost != "" && cmdData.input_proxyPort > 0) {
+                HttpProxyOptions proxyOptions = new HttpProxyOptions();
+                proxyOptions.setHost(cmdData.input_proxyHost);
+                proxyOptions.setPort(cmdData.input_proxyPort);
+                builder.withHttpProxyOptions(proxyOptions);
+            }
+            MqttClientConnection connection = builder.build();
+            builder.close();
+
+            /**
+             * Verify the connection was created
+             */
             if (connection == null)
             {
                 onApplicationFailure(new RuntimeException("MQTT connection creation failed!"));
             }
 
-            // Connect and disconnect using the connection we created
-            // (see sampleConnectAndDisconnect for implementation)
-            cmdUtils.sampleConnectAndDisconnect(connection);
-
-            // Close the connection now that we are completely done with it.
+            /**
+             * Connect and disconnect
+             */
+            CompletableFuture<Boolean> connected = connection.connect();
+            try {
+                boolean sessionPresent = connected.get();
+                System.out.println("Connected to " + (!sessionPresent ? "new" : "existing") + " session!");
+            } catch (Exception ex) {
+                throw new RuntimeException("Exception occurred during connect", ex);
+            }
+            System.out.println("Disconnecting...");
+            CompletableFuture<Void> disconnected = connection.disconnect();
+            disconnected.get();
+            System.out.println("Disconnected.");
+
+            /**
+             * Close the connection now that it is complete
+             */
             connection.close();
 
         } catch (CrtRuntimeException | InterruptedException | ExecutionException ex) {
diff --git a/samples/Jobs/src/main/java/jobs/JobsSample.java b/samples/Jobs/src/main/java/jobs/JobsSample.java
index 8a6f78f4a..a8239571a 100644
--- a/samples/Jobs/src/main/java/jobs/JobsSample.java
+++ b/samples/Jobs/src/main/java/jobs/JobsSample.java
@@ -8,7 +8,6 @@
 import software.amazon.awssdk.crt.CRT;
 import software.amazon.awssdk.crt.CrtResource;
 import software.amazon.awssdk.crt.CrtRuntimeException;
-import software.amazon.awssdk.crt.Log;
 import software.amazon.awssdk.crt.mqtt.MqttClientConnection;
 import software.amazon.awssdk.crt.mqtt.MqttClientConnectionEvents;
 import software.amazon.awssdk.crt.mqtt.QualityOfService;
@@ -31,7 +30,6 @@
 
 import java.util.LinkedList;
 import java.util.List;
-import java.util.UUID;
 import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.ExecutionException;
 
@@ -44,8 +42,6 @@ public class JobsSample {
     static String ciPropValue = System.getProperty("aws.crt.ci");
     static boolean isCI = ciPropValue != null && Boolean.valueOf(ciPropValue);
 
-    static String thingName;
-
     static CompletableFuture<Void> gotResponse;
     static List<String> availableJobs = new LinkedList<>();
     static String currentJobId;
@@ -92,17 +88,12 @@ static void onStartNextPendingJobExecutionAccepted(StartNextJobExecutionResponse
 
     public static void main(String[] args) {
 
-        cmdUtils = new CommandLineUtils();
-        cmdUtils.registerProgramName("JobsSample");
-        cmdUtils.addCommonMQTTCommands();
-        cmdUtils.registerCommand("key", "<path>", "Path to your key in PEM format.");
-        cmdUtils.registerCommand("cert", "<path>", "Path to your client certificate in PEM format.");
-        cmdUtils.registerCommand("client_id", "<int>", "Client id to use (optional, default='test-*').");
-        cmdUtils.registerCommand("thing_name", "<str>", "The name of the IoT thing.");
-        cmdUtils.registerCommand("port", "<int>", "Port to connect to on the endpoint (optional, default='8883').");
-        cmdUtils.sendArguments(args);
-
-        thingName = cmdUtils.getCommandRequired("thing_name", "");
+        /**
+         * cmdData is the arguments/input from the command line placed into a single struct for
+         * use in this sample. This handles all of the command line parsing, validating, etc.
+         * See the Utils/CommandLineUtils for more information.
+         */
+        CommandLineUtils.SampleCommandLineData cmdData = CommandLineUtils.getInputForIoTSample("Jobs", args);
 
         MqttClientConnectionEvents callbacks = new MqttClientConnectionEvents() {
             @Override
@@ -120,7 +111,22 @@ public void onConnectionResumed(boolean sessionPresent) {
 
         try {
 
-            MqttClientConnection connection = cmdUtils.buildMQTTConnection(callbacks);
+            /**
+             * Create the MQTT connection from the builder
+             */
+            AwsIotMqttConnectionBuilder builder = AwsIotMqttConnectionBuilder.newMtlsBuilderFromPath(cmdData.input_cert, cmdData.input_key);
+            if (cmdData.input_ca != "") {
+                builder.withCertificateAuthorityFromPath(null, cmdData.input_ca);
+            }
+            builder.withConnectionEventCallbacks(callbacks)
+                .withClientId(cmdData.input_clientId)
+                .withEndpoint(cmdData.input_endpoint)
+                .withPort((short)cmdData.input_port)
+                .withCleanSession(true)
+                .withProtocolOperationTimeoutMs(60000);
+            MqttClientConnection connection = builder.build();
+            builder.close();
+
             IotJobsClient jobs = new IotJobsClient(connection);
 
             CompletableFuture<Boolean> connected = connection.connect();
@@ -134,7 +140,7 @@ public void onConnectionResumed(boolean sessionPresent) {
             {
                 gotResponse = new CompletableFuture<>();
                 GetPendingJobExecutionsSubscriptionRequest subscriptionRequest = new GetPendingJobExecutionsSubscriptionRequest();
-                subscriptionRequest.thingName = thingName;
+                subscriptionRequest.thingName = cmdData.input_thingName;
                 CompletableFuture<Integer> subscribed = jobs.SubscribeToGetPendingJobExecutionsAccepted(
                         subscriptionRequest,
                         QualityOfService.AT_LEAST_ONCE,
@@ -154,7 +160,7 @@ public void onConnectionResumed(boolean sessionPresent) {
                 System.out.println("Subscribed to GetPendingJobExecutionsRejected");
 
                 GetPendingJobExecutionsRequest publishRequest = new GetPendingJobExecutionsRequest();
-                publishRequest.thingName = thingName;
+                publishRequest.thingName = cmdData.input_thingName;
                 CompletableFuture<Integer> published = jobs.PublishGetPendingJobExecutions(
                         publishRequest,
                         QualityOfService.AT_LEAST_ONCE);
@@ -179,7 +185,7 @@ public void onConnectionResumed(boolean sessionPresent) {
             for (String jobId : availableJobs) {
                 gotResponse = new CompletableFuture<>();
                 DescribeJobExecutionSubscriptionRequest subscriptionRequest = new DescribeJobExecutionSubscriptionRequest();
-                subscriptionRequest.thingName = thingName;
+                subscriptionRequest.thingName = cmdData.input_thingName;
                 subscriptionRequest.jobId = jobId;
                 jobs.SubscribeToDescribeJobExecutionAccepted(
                         subscriptionRequest,
@@ -191,7 +197,7 @@ public void onConnectionResumed(boolean sessionPresent) {
                         JobsSample::onRejectedError);
 
                 DescribeJobExecutionRequest publishRequest = new DescribeJobExecutionRequest();
-                publishRequest.thingName = thingName;
+                publishRequest.thingName = cmdData.input_thingName;
                 publishRequest.jobId = jobId;
                 publishRequest.includeJobDocument = true;
                 publishRequest.executionNumber = 1L;
@@ -207,7 +213,7 @@ public void onConnectionResumed(boolean sessionPresent) {
 
                         // Start the next pending job
                         StartNextPendingJobExecutionSubscriptionRequest subscriptionRequest = new StartNextPendingJobExecutionSubscriptionRequest();
-                        subscriptionRequest.thingName = thingName;
+                        subscriptionRequest.thingName = cmdData.input_thingName;
 
                         jobs.SubscribeToStartNextPendingJobExecutionAccepted(
                                 subscriptionRequest,
@@ -219,7 +225,7 @@ public void onConnectionResumed(boolean sessionPresent) {
                                 JobsSample::onRejectedError);
 
                         StartNextPendingJobExecutionRequest publishRequest = new StartNextPendingJobExecutionRequest();
-                        publishRequest.thingName = thingName;
+                        publishRequest.thingName = cmdData.input_thingName;
                         publishRequest.stepTimeoutInMinutes = 15L;
                         jobs.PublishStartNextPendingJobExecution(publishRequest, QualityOfService.AT_LEAST_ONCE);
 
@@ -231,7 +237,7 @@ public void onConnectionResumed(boolean sessionPresent) {
                         gotResponse = new CompletableFuture<>();
 
                         UpdateJobExecutionSubscriptionRequest subscriptionRequest = new UpdateJobExecutionSubscriptionRequest();
-                        subscriptionRequest.thingName = thingName;
+                        subscriptionRequest.thingName = cmdData.input_thingName;
                         subscriptionRequest.jobId = currentJobId;
                         jobs.SubscribeToUpdateJobExecutionAccepted(
                                 subscriptionRequest,
@@ -246,7 +252,7 @@ public void onConnectionResumed(boolean sessionPresent) {
                                 JobsSample::onRejectedError);
 
                         UpdateJobExecutionRequest publishRequest = new UpdateJobExecutionRequest();
-                        publishRequest.thingName = thingName;
+                        publishRequest.thingName = cmdData.input_thingName;
                         publishRequest.jobId = currentJobId;
                         publishRequest.executionNumber = currentExecutionNumber;
                         publishRequest.status = JobStatus.IN_PROGRESS;
@@ -264,7 +270,7 @@ public void onConnectionResumed(boolean sessionPresent) {
                         gotResponse = new CompletableFuture<>();
 
                         UpdateJobExecutionSubscriptionRequest subscriptionRequest = new UpdateJobExecutionSubscriptionRequest();
-                        subscriptionRequest.thingName = thingName;
+                        subscriptionRequest.thingName = cmdData.input_thingName;
                         subscriptionRequest.jobId = currentJobId;
                         jobs.SubscribeToUpdateJobExecutionAccepted(
                                 subscriptionRequest,
@@ -279,7 +285,7 @@ public void onConnectionResumed(boolean sessionPresent) {
                                 JobsSample::onRejectedError);
 
                         UpdateJobExecutionRequest publishRequest = new UpdateJobExecutionRequest();
-                        publishRequest.thingName = thingName;
+                        publishRequest.thingName = cmdData.input_thingName;
                         publishRequest.jobId = currentJobId;
                         publishRequest.executionNumber = currentExecutionNumber;
                         publishRequest.status = JobStatus.SUCCEEDED;
diff --git a/samples/Mqtt5/PubSub/src/main/java/pubsub/PubSub.java b/samples/Mqtt5/PubSub/src/main/java/pubsub/PubSub.java
index 138186e1c..721491997 100644
--- a/samples/Mqtt5/PubSub/src/main/java/pubsub/PubSub.java
+++ b/samples/Mqtt5/PubSub/src/main/java/pubsub/PubSub.java
@@ -9,41 +9,18 @@
 import software.amazon.awssdk.crt.CrtResource;
 import software.amazon.awssdk.crt.CrtRuntimeException;
 import software.amazon.awssdk.crt.io.ClientBootstrap;
-import software.amazon.awssdk.crt.mqtt5.Mqtt5Client;
-import software.amazon.awssdk.crt.mqtt5.Mqtt5ClientOptions;
-import software.amazon.awssdk.crt.mqtt5.NegotiatedSettings;
-import software.amazon.awssdk.crt.mqtt5.OnAttemptingConnectReturn;
-import software.amazon.awssdk.crt.mqtt5.OnConnectionFailureReturn;
-import software.amazon.awssdk.crt.mqtt5.OnConnectionSuccessReturn;
-import software.amazon.awssdk.crt.mqtt5.OnDisconnectionReturn;
-import software.amazon.awssdk.crt.mqtt5.OnStoppedReturn;
-import software.amazon.awssdk.crt.mqtt5.PublishResult;
-import software.amazon.awssdk.crt.mqtt5.PublishReturn;
-import software.amazon.awssdk.crt.mqtt5.QOS;
+import software.amazon.awssdk.crt.mqtt5.*;
 import software.amazon.awssdk.crt.mqtt5.Mqtt5ClientOptions.LifecycleEvents;
-import software.amazon.awssdk.crt.mqtt5.packets.ConnAckPacket;
-import software.amazon.awssdk.crt.mqtt5.packets.ConnectPacket;
-import software.amazon.awssdk.crt.mqtt5.packets.DisconnectPacket;
-import software.amazon.awssdk.crt.mqtt5.packets.PubAckPacket;
-import software.amazon.awssdk.crt.mqtt5.packets.PublishPacket;
-import software.amazon.awssdk.crt.mqtt5.packets.SubscribePacket;
-import software.amazon.awssdk.crt.mqtt5.packets.UserProperty;
-import software.amazon.awssdk.iot.iotjobs.model.RejectedError;
+import software.amazon.awssdk.crt.mqtt5.packets.*;
+import software.amazon.awssdk.iot.AwsIotMqtt5ClientBuilder;
 
 import java.util.List;
-import java.util.UUID;
 import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.CountDownLatch;
-import java.util.concurrent.ExecutionException;
 import java.util.concurrent.TimeUnit;
 
 import utils.commandlineutils.CommandLineUtils;
 
-/**
- * MQTT5 support is currently in <b>developer preview</b>.  We encourage feedback at all times, but feedback during the
- * preview window is especially valuable in shaping the final product.  During the preview period we may make
- * backwards-incompatible changes to the public API, but in general, this is something we will try our best to avoid.
- */
 public class PubSub {
 
     // When run normally, we want to exit nicely even if something goes wrong
@@ -54,10 +31,6 @@ public class PubSub {
 
     static CommandLineUtils cmdUtils;
 
-    static void onRejectedError(RejectedError error) {
-        System.out.println("Request rejected: " + error.code.toString() + ": " + error.message);
-    }
-
     /*
      * When called during a CI run, throw an exception that will escape and fail the exec:java task
      * When called otherwise, print what went wrong (if anything) and just continue (return from main)
@@ -142,30 +115,46 @@ public void onMessageReceived(Mqtt5Client client, PublishReturn publishReturn) {
 
     public static void main(String[] args) {
 
-        cmdUtils = new CommandLineUtils();
-        cmdUtils.registerProgramName("Mqtt5PubSub");
-        cmdUtils.addCommonMQTTCommands();
-        cmdUtils.addCommonTopicMessageCommands();
-        cmdUtils.registerCommand("key", "<path>", "Path to your key in PEM format. (will use direct MQTT to connect if defined)");
-        cmdUtils.registerCommand("cert", "<path>", "Path to your client certificate in PEM format. (will use direct MQTT to connect if defined)");
-        cmdUtils.registerCommand("signing_region", "<string>", "Websocket region to use (will use websockets to connect if defined).");
-        cmdUtils.registerCommand("client_id", "<int>", "Client id to use (optional, default='test-*').");
-        cmdUtils.registerCommand("count", "<int>", "Number of messages to publish (optional, default='10').");
-        cmdUtils.sendArguments(args);
-
-        String topic = cmdUtils.getCommandOrDefault("topic", "test/topic");
-        String message = cmdUtils.getCommandOrDefault("message", "Hello World!");
-        int messagesToPublish = Integer.parseInt(cmdUtils.getCommandOrDefault("count", String.valueOf(10)));
+        /**
+         * cmdData is the arguments/input from the command line placed into a single struct for
+         * use in this sample. This handles all of the command line parsing, validating, etc.
+         * See the Utils/CommandLineUtils for more information.
+         */
+        CommandLineUtils.SampleCommandLineData cmdData = CommandLineUtils.getInputForIoTSample("Mqtt5PubSub", args);
 
         try {
             /* Create a client based on desired connection type */
             SampleLifecycleEvents lifecycleEvents = new SampleLifecycleEvents();
-            SamplePublishEvents publishEvents = new SamplePublishEvents(messagesToPublish);
+            SamplePublishEvents publishEvents = new SamplePublishEvents(cmdData.input_count);
             Mqtt5Client client;
-            if (cmdUtils.hasCommand("cert") || cmdUtils.hasCommand("key")) {
-                client = cmdUtils.buildDirectMQTT5Connection(lifecycleEvents, publishEvents);
+
+            /**
+             * Create the MQTT connection from the builder
+             */
+            if (cmdData.input_cert != "" || cmdData.input_key != "") {
+                AwsIotMqtt5ClientBuilder builder = AwsIotMqtt5ClientBuilder.newDirectMqttBuilderWithMtlsFromPath(
+                    cmdData.input_endpoint, cmdData.input_cert, cmdData.input_key);
+                ConnectPacket.ConnectPacketBuilder connectProperties = new ConnectPacket.ConnectPacketBuilder();
+                connectProperties.withClientId(cmdData.input_clientId);
+                builder.withConnectProperties(connectProperties);
+                builder.withLifeCycleEvents(lifecycleEvents);
+                builder.withPublishEvents(publishEvents);
+                client = builder.build();
+                builder.close();
             } else {
-                client = cmdUtils.buildWebsocketMQTT5Connection(lifecycleEvents, publishEvents);
+                AwsIotMqtt5ClientBuilder.WebsocketSigv4Config websocketConfig = new AwsIotMqtt5ClientBuilder.WebsocketSigv4Config();
+                if (cmdData.input_signingRegion != "") {
+                    websocketConfig.region = cmdData.input_signingRegion;
+                }
+                AwsIotMqtt5ClientBuilder builder = AwsIotMqtt5ClientBuilder.newWebsocketMqttBuilderWithSigv4Auth(
+                    cmdData.input_endpoint, websocketConfig);
+                ConnectPacket.ConnectPacketBuilder connectProperties = new ConnectPacket.ConnectPacketBuilder();
+                connectProperties.withClientId(cmdData.input_clientId);
+                builder.withConnectProperties(connectProperties);
+                builder.withLifeCycleEvents(lifecycleEvents);
+                builder.withPublishEvents(publishEvents);
+                client = builder.build();
+                builder.close();
             }
 
             /* Connect */
@@ -178,7 +167,7 @@ public static void main(String[] args) {
 
             /* Subscribe */
             SubscribePacket.SubscribePacketBuilder subscribeBuilder = new SubscribePacket.SubscribePacketBuilder();
-            subscribeBuilder.withSubscription(topic, QOS.AT_LEAST_ONCE, false, false, SubscribePacket.RetainHandlingType.DONT_SEND);
+            subscribeBuilder.withSubscription(cmdData.input_topic, QOS.AT_LEAST_ONCE, false, false, SubscribePacket.RetainHandlingType.DONT_SEND);
             try {
                 client.subscribe(subscribeBuilder.build()).get(60, TimeUnit.SECONDS);
             } catch (Exception ex) {
@@ -187,11 +176,11 @@ public static void main(String[] args) {
 
             /* Publish */
             PublishPacket.PublishPacketBuilder publishBuilder = new PublishPacket.PublishPacketBuilder();
-            publishBuilder.withTopic(topic).withQOS(QOS.AT_LEAST_ONCE);
+            publishBuilder.withTopic(cmdData.input_topic).withQOS(QOS.AT_LEAST_ONCE);
             int count = 0;
             try {
-                while (count++ < messagesToPublish) {
-                    publishBuilder.withPayload(("\"" + message + ": " + String.valueOf(count) + "\"").getBytes());
+                while (count++ < cmdData.input_count) {
+                    publishBuilder.withPayload(("\"" + cmdData.input_message + ": " + String.valueOf(count) + "\"").getBytes());
                     CompletableFuture<PublishResult> published = client.publish(publishBuilder.build());
                     published.get(60, TimeUnit.SECONDS);
                     Thread.sleep(1000);
diff --git a/samples/Mqtt5/SharedSubscription/src/main/java/sharedsubscription/SharedSubscription.java b/samples/Mqtt5/SharedSubscription/src/main/java/sharedsubscription/SharedSubscription.java
index 7ce1085cd..721d6fe67 100644
--- a/samples/Mqtt5/SharedSubscription/src/main/java/sharedsubscription/SharedSubscription.java
+++ b/samples/Mqtt5/SharedSubscription/src/main/java/sharedsubscription/SharedSubscription.java
@@ -8,17 +8,14 @@
 import software.amazon.awssdk.crt.CRT;
 import software.amazon.awssdk.crt.CrtResource;
 import software.amazon.awssdk.crt.CrtRuntimeException;
-import software.amazon.awssdk.crt.io.ClientBootstrap;
 import software.amazon.awssdk.crt.mqtt5.*;
 import software.amazon.awssdk.crt.mqtt5.Mqtt5ClientOptions.LifecycleEvents;
 import software.amazon.awssdk.crt.mqtt5.packets.*;
 import software.amazon.awssdk.iot.AwsIotMqtt5ClientBuilder;
 
 import java.util.List;
-import java.util.UUID;
 import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.CountDownLatch;
-import java.util.concurrent.ExecutionException;
 import java.util.concurrent.TimeUnit;
 
 import utils.commandlineutils.CommandLineUtils;
@@ -189,38 +186,15 @@ public static SampleMqtt5Client createMqtt5Client(
 
     public static void main(String[] args) {
 
-        cmdUtils = new CommandLineUtils();
-        cmdUtils.registerProgramName("Mqtt5SharedSubscription");
-        cmdUtils.addCommonMQTTCommands();
-        cmdUtils.addCommonTopicMessageCommands();
-        cmdUtils.registerCommand("key", "<path>", "Path to your key in PEM format. (will use direct MQTT to connect if defined)");
-        cmdUtils.registerCommand("cert", "<path>", "Path to your client certificate in PEM format. (will use direct MQTT to connect if defined)");
-        cmdUtils.registerCommand("client_id", "<int>",
-            "Client id to use (optional, default='test-*'). " +
-            "Note that '1', '2', and '3' will be added for to the given clientIDs since this sample uses 3 clients.");
-        cmdUtils.registerCommand("count", "<int>", "Number of messages to publish (optional, default='10').");
-        cmdUtils.registerCommand("group_identifier", "<string>",
-            "The group identifier to use in the shared subscription (optional, default='java-sample')");
-        cmdUtils.sendArguments(args);
-
-        /* Pull data from the command line */
-        String input_endpoint = cmdUtils.getCommandRequired("endpoint", "");
-        String input_cert = cmdUtils.getCommandRequired("cert", "");
-        String input_key = cmdUtils.getCommandRequired("key", "");
-        String input_ca = cmdUtils.getCommandOrDefault("ca_file", "");
-        String input_clientId = cmdUtils.getCommandOrDefault("client_id", "test-" + UUID.randomUUID().toString());
-        int input_count = Integer.parseInt(cmdUtils.getCommandOrDefault("count", String.valueOf(10)));
-        String input_topic = cmdUtils.getCommandOrDefault("topic", "test/topic");
-        String input_message = cmdUtils.getCommandOrDefault("message", "Hello World!");
-        String input_groupIdentifier = cmdUtils.getCommandOrDefault("group_identifier", "java-sample");
-
-        /* If this is CI, append a UUID to the topic */
-        if (isCI) {
-            input_topic += "/" + UUID.randomUUID().toString();
-        }
+        /**
+         * cmdData is the arguments/input from the command line placed into a single struct for
+         * use in this sample. This handles all of the command line parsing, validating, etc.
+         * See the Utils/CommandLineUtils for more information.
+         */
+        CommandLineUtils.SampleCommandLineData cmdData = CommandLineUtils.getInputForIoTSample("Mqtt5SharedSubscription", args);
 
         /* Construct the shared topic */
-        String input_sharedTopic = "$share/" + input_groupIdentifier + "/" + input_topic;
+        String input_sharedTopic = "$share/" + cmdData.input_groupIdentifier + "/" + cmdData.input_topic;
 
         /* This sample uses a publisher and two subscribers */
         SampleMqtt5Client publisher = null;
@@ -228,7 +202,7 @@ public static void main(String[] args) {
         SampleMqtt5Client subscriberTwo = null;
 
         /* Make sure the message count is even */
-        if (input_count%2 != 0) {
+        if (cmdData.input_count%2 != 0) {
             onApplicationFailure(new Throwable("'--count' is an odd number. '--count' must be even or zero for this sample."));
             System.exit(1);
         }
@@ -236,14 +210,14 @@ public static void main(String[] args) {
         try {
             /* Create the MQTT5 clients: one publisher and two subscribers */
             publisher = SampleMqtt5Client.createMqtt5Client(
-                input_endpoint, input_cert, input_key, input_ca,
-                input_clientId + '1', input_count, "Publisher");
+                cmdData.input_endpoint, cmdData.input_cert, cmdData.input_key, cmdData.input_ca,
+                cmdData.input_clientId + '1', cmdData.input_count, "Publisher");
             subscriberOne = SampleMqtt5Client.createMqtt5Client(
-                input_endpoint, input_cert, input_key, input_ca,
-                input_clientId + '2', input_count, "Subscriber One");
+                cmdData.input_endpoint, cmdData.input_cert, cmdData.input_key, cmdData.input_ca,
+                cmdData.input_clientId + '2', cmdData.input_count, "Subscriber One");
             subscriberTwo = SampleMqtt5Client.createMqtt5Client(
-                input_endpoint, input_cert, input_key, input_ca,
-                input_clientId + '3', input_count, "Subscriber Two");
+                cmdData.input_endpoint, cmdData.input_cert, cmdData.input_key, cmdData.input_ca,
+                cmdData.input_clientId + '3', cmdData.input_count, "Subscriber Two");
 
             /* Connect all the clients */
             publisher.client.start();
@@ -276,11 +250,11 @@ public static void main(String[] args) {
 
             /* Publish using the publisher client */
             PublishPacket.PublishPacketBuilder publishBuilder = new PublishPacket.PublishPacketBuilder();
-            publishBuilder.withTopic(input_topic).withQOS(QOS.AT_LEAST_ONCE);
+            publishBuilder.withTopic(cmdData.input_topic).withQOS(QOS.AT_LEAST_ONCE);
             int count = 0;
-            if (input_count > 0) {
-                while (count++ < input_count) {
-                    publishBuilder.withPayload(("\"" + input_message + ": " + String.valueOf(count) + "\"").getBytes());
+            if (cmdData.input_count > 0) {
+                while (count++ < cmdData.input_count) {
+                    publishBuilder.withPayload(("\"" + cmdData.input_message + ": " + String.valueOf(count) + "\"").getBytes());
                     publisher.client.publish(publishBuilder.build()).get(60, TimeUnit.SECONDS);
                     System.out.println("[" + publisher.name + "]: Sent publish");
                     Thread.sleep(1000);
diff --git a/samples/Pkcs11Connect/src/main/java/pkcs11connect/Pkcs11Connect.java b/samples/Pkcs11Connect/src/main/java/pkcs11connect/Pkcs11Connect.java
index 857e1b5e8..b9cdff511 100644
--- a/samples/Pkcs11Connect/src/main/java/pkcs11connect/Pkcs11Connect.java
+++ b/samples/Pkcs11Connect/src/main/java/pkcs11connect/Pkcs11Connect.java
@@ -10,10 +10,7 @@
 import software.amazon.awssdk.crt.mqtt.*;
 import software.amazon.awssdk.iot.AwsIotMqttConnectionBuilder;
 
-import java.nio.charset.StandardCharsets;
-import java.util.UUID;
 import java.util.concurrent.CompletableFuture;
-import java.util.concurrent.CountDownLatch;
 import java.util.concurrent.ExecutionException;
 
 import utils.commandlineutils.CommandLineUtils;
@@ -42,37 +39,12 @@ static void onApplicationFailure(Throwable cause) {
 
     public static void main(String[] args) {
 
-        cmdUtils = new CommandLineUtils();
-        cmdUtils.registerProgramName("Pkcs11PubSub");
-        cmdUtils.addCommonMQTTCommands();
-        cmdUtils.registerCommand("cert", "<path>", "Path to your client certificate in PEM format.");
-        cmdUtils.registerCommand("client_id", "<int>", "Client id to use (optional, default='test-*').");
-        cmdUtils.registerCommand("port", "<int>", "Port to connect to on the endpoint (optional, default='8883').");
-        cmdUtils.registerCommand("pkcs11_lib", "<path>", "Path to PKCS#11 library.");
-        cmdUtils.registerCommand("pin", "<int>", "User PIN for logging into PKCS#11 token.");
-        cmdUtils.registerCommand("token_label", "<str>", "Label of PKCS#11 token to use (optional).");
-        cmdUtils.registerCommand("slot_id", "<int>", "Slot ID containing PKCS#11 token to use (optional).");
-        cmdUtils.registerCommand("key_label", "<str>", "Label of private key on the PKCS#11 token (optional).");
-        cmdUtils.sendArguments(args);
-
-        if (cmdUtils.hasCommand("help")) {
-            cmdUtils.printHelp();
-            System.exit(1);
-        }
-
-        String endpoint = cmdUtils.getCommandRequired("endpoint", "");
-        String certPath = cmdUtils.getCommandRequired("cert", "");
-        String CaPath = cmdUtils.getCommandOrDefault("ca_file", "");
-        String clientId = cmdUtils.getCommandOrDefault("client_id", "test-" + UUID.randomUUID().toString());
-        int port = Integer.parseInt(cmdUtils.getCommandOrDefault("port", "8883"));
-        String pkcs11LibPath = cmdUtils.getCommandRequired("pkcs11_lib", "");
-        String pkcs11UserPin = cmdUtils.getCommandRequired("pin", "");
-        String pkcs11TokenLabel = cmdUtils.getCommandOrDefault("token_label", "");
-        Long pkcs11SlotId = null;
-        if (cmdUtils.hasCommand("slot_id")) {
-            Long.parseLong(cmdUtils.getCommandOrDefault("slot_id", "-1"));
-        }
-        String pkcs11KeyLabel = cmdUtils.getCommandOrDefault("key_label", "");
+        /**
+         * cmdData is the arguments/input from the command line placed into a single struct for
+         * use in this sample. This handles all of the command line parsing, validating, etc.
+         * See the Utils/CommandLineUtils for more information.
+         */
+        CommandLineUtils.SampleCommandLineData cmdData = CommandLineUtils.getInputForIoTSample("Pkcs11Connect", args);
 
         MqttClientConnectionEvents callbacks = new MqttClientConnectionEvents() {
             @Override
@@ -89,11 +61,11 @@ public void onConnectionResumed(boolean sessionPresent) {
         };
 
         // Load PKCS#11 library
-        try (Pkcs11Lib pkcs11Lib = new Pkcs11Lib(pkcs11LibPath);
+        try (Pkcs11Lib pkcs11Lib = new Pkcs11Lib(cmdData.input_pkcs11LibPath);
                 TlsContextPkcs11Options pkcs11Options = new TlsContextPkcs11Options(pkcs11Lib)) {
 
-            pkcs11Options.withCertificateFilePath(certPath);
-            pkcs11Options.withUserPin(pkcs11UserPin);
+            pkcs11Options.withCertificateFilePath(cmdData.input_cert);
+            pkcs11Options.withUserPin(cmdData.input_pkcs11UserPin);
 
             // Pass arguments to help find the correct PKCS#11 token,
             // and the private key on that token. You don't need to pass
@@ -102,29 +74,29 @@ public void onConnectionResumed(boolean sessionPresent) {
             // are multiple tokens, or multiple keys to choose from, you
             // must narrow down which one should be used.
 
-            if (pkcs11TokenLabel != null && pkcs11TokenLabel != "") {
-                pkcs11Options.withTokenLabel(pkcs11TokenLabel);
+            if (cmdData.input_pkcs11TokenLabel != null && cmdData.input_pkcs11TokenLabel != "") {
+                pkcs11Options.withTokenLabel(cmdData.input_pkcs11TokenLabel);
             }
 
-            if (pkcs11SlotId != null) {
-                pkcs11Options.withSlotId(pkcs11SlotId);
+            if (cmdData.input_pkcs11SlotId != null) {
+                pkcs11Options.withSlotId(cmdData.input_pkcs11SlotId);
             }
 
-            if (pkcs11KeyLabel != null && pkcs11KeyLabel != "") {
-                pkcs11Options.withPrivateKeyObjectLabel(pkcs11KeyLabel);
+            if (cmdData.input_pkcs11KeyLabel != null && cmdData.input_pkcs11KeyLabel != "") {
+                pkcs11Options.withPrivateKeyObjectLabel(cmdData.input_pkcs11KeyLabel);
             }
 
             try (AwsIotMqttConnectionBuilder builder = AwsIotMqttConnectionBuilder
                     .newMtlsPkcs11Builder(pkcs11Options)) {
 
-                if (CaPath != null && CaPath != "") {
-                    builder.withCertificateAuthorityFromPath(null, CaPath);
+                if (cmdData.input_ca != null && cmdData.input_ca != "") {
+                    builder.withCertificateAuthorityFromPath(null, cmdData.input_ca);
                 }
 
                 builder.withConnectionEventCallbacks(callbacks)
-                        .withClientId(clientId)
-                        .withEndpoint(endpoint)
-                        .withPort((short) port)
+                        .withClientId(cmdData.input_clientId)
+                        .withEndpoint(cmdData.input_endpoint)
+                        .withPort((short) cmdData.input_port)
                         .withCleanSession(true)
                         .withProtocolOperationTimeoutMs(60000);
 
diff --git a/samples/PubSubStress/pom.xml b/samples/PubSubStress/pom.xml
deleted file mode 100644
index 4b2205ffe..000000000
--- a/samples/PubSubStress/pom.xml
+++ /dev/null
@@ -1,64 +0,0 @@
-<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
-    <modelVersion>4.0.0</modelVersion>
-    <groupId>software.amazon.awssdk.iotdevicesdk</groupId>
-    <artifactId>PubSubStress</artifactId>
-    <packaging>jar</packaging>
-    <version>1.0-SNAPSHOT</version>
-    <name>${project.groupId}:${project.artifactId}</name>
-    <description>Java bindings for the AWS IoT Core Service</description>
-    <url>https://github.com/awslabs/aws-iot-device-sdk-java-v2</url>
-    <properties>
-        <maven.compiler.source>1.8</maven.compiler.source>
-        <maven.compiler.target>1.8</maven.compiler.target>
-        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
-    </properties>
-    <profiles>
-        <profile>
-            <id>latest-release</id>
-            <dependencies>
-                <dependency>
-                    <groupId>software.amazon.awssdk.iotdevicesdk</groupId>
-                    <artifactId>aws-iot-device-sdk</artifactId>
-                    <version>1.11.5</version>
-                </dependency>
-            </dependencies>
-        </profile>
-        <profile>
-            <id>default</id>
-            <activation>
-                <activeByDefault>true</activeByDefault>
-            </activation>
-            <dependencies>
-                <dependency>
-                    <groupId>software.amazon.awssdk.iotdevicesdk</groupId>
-                    <artifactId>aws-iot-device-sdk</artifactId>
-                    <version>1.0.0-SNAPSHOT </version>
-                </dependency>
-            </dependencies>
-        </profile>
-    </profiles>
-    <build>
-        <plugins>
-            <plugin>
-                <groupId>org.codehaus.mojo</groupId>
-                <artifactId>build-helper-maven-plugin</artifactId>
-                <version>3.2.0</version>
-                <executions>
-                    <execution>
-                        <id>add-source</id>
-                        <phase>generate-sources</phase>
-                        <goals>
-                            <goal>add-source</goal>
-                        </goals>
-                        <configuration>
-                            <sources>
-                                <source>../Utils/CommandLineUtils</source>
-                            </sources>
-                        </configuration>
-                    </execution>
-                </executions>
-            </plugin>
-        </plugins>
-    </build>
-</project>
diff --git a/samples/PubSubStress/src/main/java/pubsubstress/PubSubStress.java b/samples/PubSubStress/src/main/java/pubsubstress/PubSubStress.java
deleted file mode 100644
index 02d8bad45..000000000
--- a/samples/PubSubStress/src/main/java/pubsubstress/PubSubStress.java
+++ /dev/null
@@ -1,282 +0,0 @@
-/**
- * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
- * SPDX-License-Identifier: Apache-2.0.
- */
-
-package pubsubstress;
-
-import software.amazon.awssdk.crt.CRT;
-import software.amazon.awssdk.crt.CrtResource;
-import software.amazon.awssdk.crt.http.HttpProxyOptions;
-import software.amazon.awssdk.crt.Log;
-import software.amazon.awssdk.crt.mqtt.MqttClientConnection;
-import software.amazon.awssdk.crt.mqtt.MqttClientConnectionEvents;
-import software.amazon.awssdk.crt.mqtt.MqttMessage;
-import software.amazon.awssdk.crt.mqtt.QualityOfService;
-import software.amazon.awssdk.iot.AwsIotMqttConnectionBuilder;
-import software.amazon.awssdk.iot.iotjobs.model.RejectedError;
-
-import java.io.UnsupportedEncodingException;
-import java.util.*;
-import java.util.concurrent.CompletableFuture;
-import java.util.concurrent.TimeUnit;
-
-import utils.commandlineutils.CommandLineUtils;
-
-public class PubSubStress {
-    private static final int PROGRESS_OP_COUNT = 100;
-
-    static String clientId = "test-" + UUID.randomUUID().toString();
-    static String topic = "test/topic";
-    static String message = "Hello World!";
-    static int    messagesToPublish = 5000;
-    static int connectionCount = 1000;
-    static int eventLoopThreadCount = 1;
-    static int testIterations = 1;
-
-    private static Map<String, MqttClientConnection> connections = new HashMap<>();
-    private static List<String> validClientIds = new ArrayList<>();
-    private static List<String> validTopics = new ArrayList<>();
-
-    static CommandLineUtils cmdUtils;
-
-    static void onRejectedError(RejectedError error) {
-        System.out.println("Request rejected: " + error.code.toString() + ": " + error.message);
-    }
-
-    static class ConnectionState {
-        public ConnectionState() {}
-
-        public String clientId;
-        public String topic;
-        public MqttClientConnection connection;
-        public CompletableFuture<Boolean> connectFuture;
-        public CompletableFuture<Integer> subscribeFuture;
-    }
-
-    static void initConnections() {
-        List<ConnectionState> connectionsInProgress = new ArrayList<>();
-
-        for (int i = 0; i < connectionCount; ++i) {
-            MqttClientConnectionEvents callbacks = new MqttClientConnectionEvents() {
-                @Override
-                public void onConnectionInterrupted(int errorCode) {
-                    if (errorCode != 0) {
-                        System.out.println("Connection interrupted: " + errorCode + ": " + CRT.awsErrorString(errorCode));
-                    }
-                }
-
-                @Override
-                public void onConnectionResumed(boolean sessionPresent) {
-                    System.out.println("Connection resumed: " + (sessionPresent ? "existing session" : "clean session"));
-                }
-            };
-
-            String newClientId = String.format("%s%d", clientId, i);
-            MqttClientConnection connection = cmdUtils.buildMQTTConnection(callbacks);
-
-            try {
-                ConnectionState connectionState = new ConnectionState();
-                connectionState.clientId = newClientId;
-                connectionState.connectFuture = connection.connect();
-                connectionState.connection = connection;
-
-                connectionsInProgress.add(connectionState);
-
-                if ((i + 1) % PROGRESS_OP_COUNT == 0) {
-                    System.out.println(String.format("(Main Thread) Connect start count: %d", i + 1));
-                }
-
-                // Simple throttle to avoid Iot Connect/Second limit
-                Thread.sleep(5);
-            } catch (Exception ignored) {
-                connection.disconnect();
-                connection.close();
-            }
-        }
-
-        System.out.println(String.format("(Main Thread) Started %d connections", connectionsInProgress.size()));
-
-        for (int i = 0; i < connectionsInProgress.size(); ++i) {
-            ConnectionState connectionState = connectionsInProgress.get(i);
-            CompletableFuture<Boolean> connectFuture = connectionState.connectFuture;
-            if (connectFuture == null) {
-                continue;
-            }
-
-            try {
-                connectFuture.get(5, TimeUnit.SECONDS);
-
-                String clientTopic = String.format("%s%d", topic, i);
-                connectionState.topic = clientTopic;
-                connectionState.subscribeFuture = connectionState.connection.subscribe(clientTopic, QualityOfService.AT_LEAST_ONCE, (message) -> {
-                    try {
-                        String payload = new String(message.getPayload(), "UTF-8");
-                    } catch (UnsupportedEncodingException ex) {
-                        System.out.println(String.format("(Topic %s): Unable to decode payload: %s", clientTopic, ex.getMessage()));
-                    }
-                });
-
-                if ((i + 1) % PROGRESS_OP_COUNT == 0) {
-                    System.out.println(String.format("(Main Thread) Subscribe start count: %d", i + 1));
-                }
-
-                // Simple throttle to avoid Iot Subscribe/Second limit
-                Thread.sleep(5);
-            } catch (Exception e) {
-                connectionState.connection.disconnect();
-                connectionState.connection.close();
-                connectionState.connection = null;
-            }
-        }
-
-        System.out.println(String.format("(Main Thread) Started subscriptions for %d connections", connectionsInProgress.size()));
-
-        for (int i = 0; i < connectionsInProgress.size(); ++i) {
-            ConnectionState connectionState = connectionsInProgress.get(i);
-            CompletableFuture<Integer> subscribeFuture = connectionState.subscribeFuture;
-            if (subscribeFuture == null) {
-                continue;
-            }
-
-            try {
-                subscribeFuture.get(5, TimeUnit.SECONDS);
-
-                connections.put(connectionState.clientId, connectionState.connection);
-                validClientIds.add(connectionState.clientId);
-                validTopics.add(connectionState.topic);
-            } catch (Exception e) {
-                connectionState.connection.disconnect();
-                connectionState.connection.close();
-                connectionState.connection = null;
-            }
-        }
-
-        System.out.println(String.format("(Main Thread) Successfully established %d connections", connections.size()));
-    }
-
-    private static void cleanupConnections() {
-        List<CompletableFuture<Void>> disconnectFutures = new ArrayList<>();
-
-        for (MqttClientConnection connection : connections.values()) {
-            try {
-                disconnectFutures.add(connection.disconnect());
-            } catch (Exception e) {
-                System.out.println(String.format("Disconnect Exception: %s", e.getMessage()));
-            }
-        }
-
-        for (CompletableFuture<Void> future : disconnectFutures) {
-            try {
-                future.get(60, TimeUnit.SECONDS);
-            } catch (Exception e) {
-                System.out.println(String.format("Disconnect Future Exception: %s", e.getMessage()));
-            }
-        }
-
-        for (MqttClientConnection connection : connections.values()) {
-            try {
-                connection.close();
-            } catch (Exception e) {
-                System.out.println(String.format("Close Exception: %s", e.getMessage()));
-            }
-        }
-    }
-
-    public static void main(String[] args) {
-
-        cmdUtils = new CommandLineUtils();
-        cmdUtils.registerProgramName("PubSubStress");
-        cmdUtils.addCommonMQTTCommands();
-        cmdUtils.addCommonTopicMessageCommands();
-        cmdUtils.registerCommand("key", "<path>", "Path to your key in PEM format.");
-        cmdUtils.registerCommand("cert", "<path>", "Path to your client certificate in PEM format.");
-        cmdUtils.registerCommand("client_id", "<int>", "Client id to use (optional, default='test-*')");
-        cmdUtils.registerCommand("count", "<int>", "Number of messages to publish (optional, default='10').");
-        cmdUtils.registerCommand("connections", "<int>", "Number of connections to make (optional, default='1000').");
-        cmdUtils.registerCommand("threads", "<int>", "Number of IO threads to use (optional, default='1').");
-        cmdUtils.registerCommand("iterations", "<int>", "Number of times to repeat the basic stress test logic (optional, default='1').");
-        cmdUtils.registerCommand("signing_region", "<str>", "Use websockets (optional). Sets the Websocket signing region to use (default='us-east-1').");
-        cmdUtils.registerCommand("proxy_host", "<str>", "Websocket proxy host to use (optional, required for websockets).");
-        cmdUtils.registerCommand("proxy_port", "<int>", "Websocket proxy port to use (optional, required for websockets).");
-        cmdUtils.sendArguments(args);
-
-        topic = cmdUtils.getCommandOrDefault("topic", topic);
-        message = cmdUtils.getCommandOrDefault("message", message);
-        messagesToPublish = Integer.parseInt(cmdUtils.getCommandOrDefault("count", String.valueOf(messagesToPublish)));
-        connectionCount = Integer.parseInt(cmdUtils.getCommandOrDefault("connections", String.valueOf(connectionCount)));
-        eventLoopThreadCount = Integer.parseInt(cmdUtils.getCommandOrDefault("threads", String.valueOf(eventLoopThreadCount)));
-        testIterations = Integer.parseInt(cmdUtils.getCommandOrDefault("iterations", String.valueOf(testIterations)));
-
-        int iteration = 0;
-        while(iteration < testIterations) {
-            System.out.println(String.format("Starting iteration %d", iteration));
-
-            try {
-                try {
-                    initConnections();
-
-                    Log.log(Log.LogLevel.Info, Log.LogSubject.MqttGeneral, "START OF PUBLISH......");
-
-                    Random rng = new Random(0);
-
-                    List<CompletableFuture<Integer>> publishFutures = new ArrayList<>();
-
-                    for (int count = 0; count < messagesToPublish; ++count) {
-                        String messageContent = String.format("%s #%d", message, count + 1);
-
-                        // Pick a random connection to publish from
-                        String connectionId = validClientIds.get(Math.abs(rng.nextInt()) % validClientIds.size());
-                        MqttClientConnection connection = connections.get(connectionId);
-
-                        // Pick a random subscribed topic to publish to
-                        String publishTopic = validTopics.get(Math.abs(rng.nextInt()) % validTopics.size());
-
-                        try {
-                            publishFutures.add(connection.publish(new MqttMessage(publishTopic, messageContent.getBytes(), QualityOfService.AT_LEAST_ONCE, false)));
-                        } catch (Exception e) {
-                            System.out.println(String.format("Publishing Exception: %s", e.getMessage()));
-                        }
-
-                        if (count % PROGRESS_OP_COUNT == 0) {
-                            System.out.println(String.format("(Main Thread) Message publish count: %d", count));
-                            Thread.sleep(10); // this should keep the aggregate publish rate under 10K/s
-                        }
-                    }
-
-                    for (CompletableFuture<Integer> publishFuture : publishFutures) {
-                        publishFuture.get();
-                    }
-
-                    System.out.println("zzzzz");
-
-                    Thread.sleep(1000);
-                } catch (Exception e) {
-                    System.out.println(String.format("Exception: %s", e.getMessage()));
-                } finally {
-                    cleanupConnections();
-                }
-            } catch (Exception e) {
-                System.out.println("Exception encountered: " + e.toString());
-            }
-
-            System.out.println("Complete! Waiting on managed cleanup");
-            CrtResource.waitForNoResources();
-            System.out.println("Managed cleanup complete");
-
-            /* Not particularly effective, but psychologically reassuring to do before checking memory */
-            for (int i = 0; i < 10; ++i) {
-                System.gc();
-            }
-            long nativeMemoryInUse = CRT.nativeMemory();
-            System.out.println(String.format("Native memory: %d", nativeMemoryInUse));
-            long javaMemoryInUse = (Runtime.getRuntime().totalMemory() - Runtime.getRuntime().freeMemory());
-            System.out.println(String.format("Java memory: %d", javaMemoryInUse));
-
-            iteration++;
-
-            validClientIds.clear();
-            validTopics.clear();
-        }
-    }
-}
diff --git a/samples/README.md b/samples/README.md
index 2254c018f..f0c7efda6 100644
--- a/samples/README.md
+++ b/samples/README.md
@@ -4,25 +4,20 @@
 * [Basic Connect](./BasicConnect/README.md)
 * [Websocket Connect](./WebsocketConnect/README.md)
 * [Pkcs11 Connect](./Pkcs11Connect/README.md)
-* [Raw Connect](./RawConnect/README.md)
 * [WindowsCert Connect](./WindowsCertConnect/README.md)
 * [X509 Connect](./X509CredentialsProviderConnect/README.md)
 * [CustomAuthorizer Connect](./CustomAuthorizerConnect/README.md)
 * [JavaKeystore Connect](./JavaKeystoreConnect/README.md)
 * [Cognito Connect](./CognitoConnect/README.md)
-* [CustomKeyOperationPubSub](./CustomKeyOpsPubSub/README.md)
+* [CustomKeyOperation Connect](./CustomKeyOpsConnect/README.md)
 * [Shadow](./Shadow/README.md)
 * [Jobs](./Jobs/README.md)
-* [fleet provisioning](./Identity/README.md)
+* [fleet provisioning](./FleetProvisioning/README.md)
 * [Greengrass Discovery](./Greengrass/README.md)
 * [Greengrass IPC](./GreengrassIPC/README.md)
 * [MQTT5 PubSub](./Mqtt5/PubSub/README.md)
 * [MQTT5 Shared Subscription](./Mqtt5/SharedSubscription/README.md)
 
-**Additional sample apps currently without READMEs:**
-
-* [PubSubStress](https://github.com/aws/aws-iot-device-sdk-java-v2/tree/main/samples/PubSubStress)
-
 ### Note
 
 Note that **all samples will show their options by passing in `--help`**. For example:
diff --git a/samples/RawConnect/README.md b/samples/RawConnect/README.md
deleted file mode 100644
index 841dfa870..000000000
--- a/samples/RawConnect/README.md
+++ /dev/null
@@ -1,48 +0,0 @@
-# Raw Connect
-
-[**Return to main sample list**](../README.md)
-
-This sample is exactly like [Basic Connect](../BasicConnect/README.md) in terms of functionality, but it sets up the connection manually in a "raw" way rather than using helper classes that make creating the connection easier. On startup, the device connects to the server using the certificate and key files, and then disconnects. This sample is for reference on connecting via certificate and key files.
-
-Your IoT Core Thing's [Policy](https://docs.aws.amazon.com/iot/latest/developerguide/iot-policies.html) must provide privileges for this sample to connect. Below is a sample policy that can be used on your IoT Core Thing that will allow this sample to run as intended.
-
-<details>
-<summary>(see sample policy)</summary>
-<pre>
-{
-  "Version": "2012-10-17",
-  "Statement": [
-    {
-      "Effect": "Allow",
-      "Action": [
-        "iot:Connect"
-      ],
-      "Resource": [
-        "arn:aws:iot:<b>region</b>:<b>account</b>:client/test-*"
-      ]
-    }
-  ]
-}
-</pre>
-
-Replace with the following with the data from your AWS account:
-* `<region>`: The AWS IoT Core region where you created your AWS IoT Core thing you wish to use with this sample. For example `us-east-1`.
-* `<account>`: Your AWS IoT Core account ID. This is the set of numbers in the top right next to your AWS account name when using the AWS IoT Core website.
-
-Note that in a real application, you may want to avoid the use of wildcards in your ClientID or use them selectively. Please follow best practices when working with AWS on production applications using the SDK. Also, for the purposes of this sample, please make sure your policy allows a client ID of `test-*` to connect or use `--client_id <client ID here>` to send the client ID your policy supports.
-
-</details>
-
-## How to run
-
-To run the raw connect sample use the following command:
-
-```sh
-mvn compile exec:java -pl samples/RawConnect -Dexec.mainClass=rawconnect.RawConnect -Dexec.args="--endpoint <endpoint> --cert <path to certificate> --key <path to private key>"
-```
-
-You can also pass a Certificate Authority file (CA) if your certificate and key combination requires it:
-
-```sh
-mvn compile exec:java -pl samples/RawConnect -Dexec.mainClass=rawconnect.RawConnect -Dexec.args="--endpoint <endpoint> --cert <path to certificate> --key <path to private key> --ca_file <path to CA file>"
-```
diff --git a/samples/RawConnect/pom.xml b/samples/RawConnect/pom.xml
deleted file mode 100644
index 6c74a1e93..000000000
--- a/samples/RawConnect/pom.xml
+++ /dev/null
@@ -1,72 +0,0 @@
-<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
-    <modelVersion>4.0.0</modelVersion>
-    <groupId>software.amazon.awssdk.iotdevicesdk</groupId>
-    <artifactId>RawConnect</artifactId>
-    <packaging>jar</packaging>
-    <version>1.0-SNAPSHOT</version>
-    <name>${project.groupId}:${project.artifactId}</name>
-    <description>Java bindings for the AWS IoT Core Service</description>
-    <url>https://github.com/awslabs/aws-iot-device-sdk-java-v2</url>
-    <properties>
-        <maven.compiler.source>1.8</maven.compiler.source>
-        <maven.compiler.target>1.8</maven.compiler.target>
-        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
-    </properties>
-    <profiles>
-        <profile>
-            <id>latest-release</id>
-            <dependencies>
-                <dependency>
-                    <groupId>software.amazon.awssdk.iotdevicesdk</groupId>
-                    <artifactId>aws-iot-device-sdk</artifactId>
-                    <version>1.11.5</version>
-                </dependency>
-            </dependencies>
-        </profile>
-        <profile>
-            <id>default</id>
-            <activation>
-                <activeByDefault>true</activeByDefault>
-            </activation>
-            <dependencies>
-                <dependency>
-                    <groupId>software.amazon.awssdk.iotdevicesdk</groupId>
-                    <artifactId>aws-iot-device-sdk</artifactId>
-                    <version>1.0.0-SNAPSHOT </version>
-                </dependency>
-            </dependencies>
-        </profile>
-    </profiles>
-    <build>
-        <plugins>
-            <plugin>
-                <groupId>org.codehaus.mojo</groupId>
-                <artifactId>exec-maven-plugin</artifactId>
-                <version>1.4.0</version>
-                <configuration>
-                    <mainClass>rawconnect.RawConnect</mainClass>
-                </configuration>
-            </plugin>
-            <plugin>
-                <groupId>org.codehaus.mojo</groupId>
-                <artifactId>build-helper-maven-plugin</artifactId>
-                <version>3.2.0</version>
-                <executions>
-                    <execution>
-                        <id>add-source</id>
-                        <phase>generate-sources</phase>
-                        <goals>
-                            <goal>add-source</goal>
-                        </goals>
-                        <configuration>
-                            <sources>
-                                <source>../Utils/CommandLineUtils</source>
-                            </sources>
-                        </configuration>
-                    </execution>
-                </executions>
-            </plugin>
-        </plugins>
-    </build>
-</project>
diff --git a/samples/RawConnect/src/main/java/rawconnect/RawConnect.java b/samples/RawConnect/src/main/java/rawconnect/RawConnect.java
deleted file mode 100644
index 2a66f10aa..000000000
--- a/samples/RawConnect/src/main/java/rawconnect/RawConnect.java
+++ /dev/null
@@ -1,143 +0,0 @@
-/**
- * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
- * SPDX-License-Identifier: Apache-2.0.
- */
-
-package rawconnect;
-
-import software.amazon.awssdk.crt.CRT;
-import software.amazon.awssdk.crt.CrtResource;
-import software.amazon.awssdk.crt.CrtRuntimeException;
-import software.amazon.awssdk.crt.Log;
-import software.amazon.awssdk.crt.io.ClientBootstrap;
-import software.amazon.awssdk.crt.io.TlsContext;
-import software.amazon.awssdk.crt.io.TlsContextOptions;
-import software.amazon.awssdk.crt.mqtt.*;
-
-import java.nio.charset.StandardCharsets;
-import java.util.Arrays;
-import java.util.List;
-import java.util.UUID;
-import java.util.concurrent.CompletableFuture;
-import java.util.concurrent.CountDownLatch;
-import java.util.concurrent.ExecutionException;
-
-import utils.commandlineutils.CommandLineUtils;
-
-public class RawConnect {
-    // When run normally, we want to exit nicely even if something goes wrong
-    // When run from CI, we want to let an exception escape which in turn causes the
-    // exec:java task to return a non-zero exit code
-    static String ciPropValue = System.getProperty("aws.crt.ci");
-    static boolean isCI = ciPropValue != null && Boolean.valueOf(ciPropValue);
-
-    static CommandLineUtils cmdUtils;
-
-    public static void main(String[] args) {
-
-        cmdUtils = new CommandLineUtils();
-        cmdUtils.registerProgramName("RawConnect");
-        cmdUtils.addCommonMQTTCommands();
-        cmdUtils.registerCommand("key", "<path>", "Path to your key in PEM format.");
-        cmdUtils.registerCommand("cert", "<path>", "Path to your client certificate in PEM format.");
-        cmdUtils.addCommonProxyCommands();
-        cmdUtils.registerCommand("client_id", "<int>", "Client id to use (optional, default='test-*').");
-        cmdUtils.registerCommand("username", "<str>", "Username to use as part of the connection/authentication process.");
-        cmdUtils.registerCommand("password", "<str>", "Password to use as part of the connection/authentication process.");
-        cmdUtils.registerCommand("protocol", "<str>", "ALPN protocol to use (optional, default='x-amzn-mqtt-ca').");
-        cmdUtils.registerCommand("auth_params", "<comma delimited list>",
-                "Comma delimited list of auth parameters. For websockets these will be set as headers. " +
-                "For raw mqtt these will be appended to user_name. (optional)");
-        cmdUtils.sendArguments(args);
-
-        String endpoint = cmdUtils.getCommandRequired("endpoint", "");
-        String clientId = cmdUtils.getCommandOrDefault("client_id", "test-" + UUID.randomUUID().toString());
-        String caPath = cmdUtils.getCommandOrDefault("ca_file", "");
-        String certPath = cmdUtils.getCommandRequired("cert", "");
-        String keyPath = cmdUtils.getCommandRequired("key", "");
-        String proxyHost = cmdUtils.getCommandOrDefault("proxy_host", "");
-        int proxyPort = Integer.parseInt(cmdUtils.getCommandOrDefault("proxy_port", "8080"));
-        String userName = cmdUtils.getCommandRequired("username", "");
-        String password = cmdUtils.getCommandRequired("password", "");
-        String protocolName = cmdUtils.getCommandOrDefault("protocol", "x-amzn-mqtt-ca");
-        List<String> authParams = null;
-        if (cmdUtils.hasCommand("auth_params")) {
-            authParams = Arrays.asList(cmdUtils.getCommand("auth_params").split("\\s*,\\s*"));
-        }
-
-        MqttClientConnectionEvents callbacks = new MqttClientConnectionEvents() {
-            @Override
-            public void onConnectionInterrupted(int errorCode) {
-                if (errorCode != 0) {
-                    System.out.println("Connection interrupted: " + errorCode + ": " + CRT.awsErrorString(errorCode));
-                }
-            }
-
-            @Override
-            public void onConnectionResumed(boolean sessionPresent) {
-                System.out.println("Connection resumed: " + (sessionPresent ? "existing session" : "clean session"));
-            }
-        };
-
-        if (authParams != null && authParams.size() > 0) {
-            if (userName.length() > 0) {
-                StringBuilder usernameBuilder = new StringBuilder();
-
-                usernameBuilder.append(userName);
-                usernameBuilder.append("?");
-                for (int i = 0; i < authParams.size(); ++i) {
-                    usernameBuilder.append(authParams.get(i));
-                    if (i + 1 < authParams.size()) {
-                        usernameBuilder.append("&");
-                    }
-                }
-                userName = usernameBuilder.toString();
-            }
-        }
-
-        try(
-            TlsContextOptions tlsContextOptions = TlsContextOptions.createWithMtlsFromPath(certPath, keyPath)) {
-
-            if (caPath != null) {
-                tlsContextOptions.overrideDefaultTrustStoreFromPath(null, caPath);
-            }
-
-            int port = 8883;
-            if (TlsContextOptions.isAlpnSupported()) {
-                port = 443;
-                tlsContextOptions.withAlpnList(protocolName);
-            }
-
-            try(TlsContext tlsContext = new TlsContext(tlsContextOptions);
-                MqttClient client = new MqttClient(tlsContext);
-                MqttConnectionConfig config = new MqttConnectionConfig()) {
-
-                config.setMqttClient(client);
-                config.setClientId(clientId);
-                config.setConnectionCallbacks(callbacks);
-                config.setCleanSession(true);
-                config.setEndpoint(endpoint);
-                config.setPort(port);
-
-                if (userName != null && userName.length() > 0) {
-                    config.setLogin(userName, password);
-                }
-
-                try (MqttClientConnection connection = new MqttClientConnection(config)) {
-
-                    // Connect and disconnect using the connection we created
-                    // (see sampleConnectAndDisconnect for implementation)
-                    cmdUtils.sampleConnectAndDisconnect(connection);
-
-                    // Close the connection now that we are completely done with it.
-                    connection.close();
-                }
-            }
-        } catch (CrtRuntimeException | InterruptedException | ExecutionException ex) {
-            System.out.println("Exception encountered: " + ex.toString());
-        }
-
-        CrtResource.waitForNoResources();
-        System.out.println("Complete!");
-    }
-}
diff --git a/samples/Shadow/src/main/java/shadow/ShadowSample.java b/samples/Shadow/src/main/java/shadow/ShadowSample.java
index 541e2e50c..bd25ac100 100644
--- a/samples/Shadow/src/main/java/shadow/ShadowSample.java
+++ b/samples/Shadow/src/main/java/shadow/ShadowSample.java
@@ -8,7 +8,6 @@
 import software.amazon.awssdk.crt.CRT;
 import software.amazon.awssdk.crt.CrtResource;
 import software.amazon.awssdk.crt.CrtRuntimeException;
-import software.amazon.awssdk.crt.Log;
 import software.amazon.awssdk.crt.mqtt.MqttClientConnection;
 import software.amazon.awssdk.crt.mqtt.MqttClientConnectionEvents;
 import software.amazon.awssdk.crt.mqtt.QualityOfService;
@@ -29,7 +28,6 @@
 import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.ExecutionException;
 import java.util.Scanner;
-import java.util.UUID;
 
 import utils.commandlineutils.CommandLineUtils;
 
@@ -40,7 +38,7 @@ public class ShadowSample {
     static String ciPropValue = System.getProperty("aws.crt.ci");
     static boolean isCI = ciPropValue != null && Boolean.valueOf(ciPropValue);
 
-    static String thingName;
+    static String input_thingName;
     final static String SHADOW_PROPERTY = "color";
     final static String SHADOW_VALUE_DEFAULT = "off";
 
@@ -142,7 +140,7 @@ static CompletableFuture<Void> changeShadowValue(String value) {
         // build a request to let the service know our current value and desired value, and that we only want
         // to update if the version matches the version we know about
         UpdateShadowRequest request = new UpdateShadowRequest();
-        request.thingName = thingName;
+        request.thingName = input_thingName;
         request.state = new ShadowState();
 
         if (value.compareToIgnoreCase("clear_shadow") == 0) {
@@ -187,17 +185,14 @@ else if (value.compareToIgnoreCase("null") == 0) {
     }
 
     public static void main(String[] args) {
-        cmdUtils = new CommandLineUtils();
-        cmdUtils.registerProgramName("ShadowSample");
-        cmdUtils.addCommonMQTTCommands();
-        cmdUtils.registerCommand("key", "<path>", "Path to your key in PEM format.");
-        cmdUtils.registerCommand("cert", "<path>", "Path to your client certificate in PEM format.");
-        cmdUtils.registerCommand("port", "<int>", "Port to use (optional, default='8883').");
-        cmdUtils.registerCommand("thing_name", "<str>", "The name of the IoT thing.");
-        cmdUtils.registerCommand("client_id", "<int>", "Client id to use (optional, default='test-*')");
-        cmdUtils.sendArguments(args);
-
-        thingName = cmdUtils.getCommandRequired("thing_name", "");
+
+        /**
+         * cmdData is the arguments/input from the command line placed into a single struct for
+         * use in this sample. This handles all of the command line parsing, validating, etc.
+         * See the Utils/CommandLineUtils for more information.
+         */
+        CommandLineUtils.SampleCommandLineData cmdData = CommandLineUtils.getInputForIoTSample("Shadow", args);
+        input_thingName = cmdData.input_thingName;
 
         MqttClientConnectionEvents callbacks = new MqttClientConnectionEvents() {
             @Override
@@ -215,10 +210,26 @@ public void onConnectionResumed(boolean sessionPresent) {
 
         try {
 
-            MqttClientConnection connection = cmdUtils.buildMQTTConnection(callbacks);
-
+            /**
+             * Create the MQTT connection from the builder
+             */
+            AwsIotMqttConnectionBuilder builder = AwsIotMqttConnectionBuilder.newMtlsBuilderFromPath(cmdData.input_cert, cmdData.input_key);
+            if (cmdData.input_ca != "") {
+                builder.withCertificateAuthorityFromPath(null, cmdData.input_ca);
+            }
+            builder.withConnectionEventCallbacks(callbacks)
+                .withClientId(cmdData.input_clientId)
+                .withEndpoint(cmdData.input_endpoint)
+                .withPort((short)cmdData.input_port)
+                .withCleanSession(true)
+                .withProtocolOperationTimeoutMs(60000);
+            MqttClientConnection connection = builder.build();
+            builder.close();
+
+            // Create the shadow client
             shadow = new IotShadowClient(connection);
 
+            // Connect
             CompletableFuture<Boolean> connected = connection.connect();
             try {
                 boolean sessionPresent = connected.get();
@@ -227,9 +238,12 @@ public void onConnectionResumed(boolean sessionPresent) {
                 throw new RuntimeException("Exception occurred during connect", ex);
             }
 
+            /**
+             * Subscribe to shadow topics
+             */
             System.out.println("Subscribing to shadow delta events...");
             ShadowDeltaUpdatedSubscriptionRequest requestShadowDeltaUpdated = new ShadowDeltaUpdatedSubscriptionRequest();
-            requestShadowDeltaUpdated.thingName = thingName;
+            requestShadowDeltaUpdated.thingName = input_thingName;
             CompletableFuture<Integer> subscribedToDeltas =
                     shadow.SubscribeToShadowDeltaUpdatedEvents(
                             requestShadowDeltaUpdated,
@@ -239,7 +253,7 @@ public void onConnectionResumed(boolean sessionPresent) {
 
             System.out.println("Subscribing to update responses...");
             UpdateShadowSubscriptionRequest requestUpdateShadow = new UpdateShadowSubscriptionRequest();
-            requestUpdateShadow.thingName = thingName;
+            requestUpdateShadow.thingName = input_thingName;
             CompletableFuture<Integer> subscribedToUpdateAccepted =
                     shadow.SubscribeToUpdateShadowAccepted(
                             requestUpdateShadow,
@@ -255,7 +269,7 @@ public void onConnectionResumed(boolean sessionPresent) {
 
             System.out.println("Subscribing to get responses...");
             GetShadowSubscriptionRequest requestGetShadow = new GetShadowSubscriptionRequest();
-            requestGetShadow.thingName = thingName;
+            requestGetShadow.thingName = input_thingName;
             CompletableFuture<Integer> subscribedToGetShadowAccepted =
                     shadow.SubscribeToGetShadowAccepted(
                             requestGetShadow,
@@ -273,7 +287,7 @@ public void onConnectionResumed(boolean sessionPresent) {
 
             System.out.println("Requesting current shadow state...");
             GetShadowRequest getShadowRequest = new GetShadowRequest();
-            getShadowRequest.thingName = thingName;
+            getShadowRequest.thingName = input_thingName;
             CompletableFuture<Integer> publishedGetShadow = shadow.PublishGetShadow(
                     getShadowRequest,
                     QualityOfService.AT_LEAST_ONCE);
@@ -310,6 +324,7 @@ public void onConnectionResumed(boolean sessionPresent) {
                 }
             }
 
+            // Disconnect
             CompletableFuture<Void> disconnected = connection.disconnect();
             disconnected.get();
 
diff --git a/samples/Utils/CommandLineUtils/utils/commandlineutils/CommandLineUtils.java b/samples/Utils/CommandLineUtils/utils/commandlineutils/CommandLineUtils.java
index 9bdfc9dc5..b2fffcc5e 100644
--- a/samples/Utils/CommandLineUtils/utils/commandlineutils/CommandLineUtils.java
+++ b/samples/Utils/CommandLineUtils/utils/commandlineutils/CommandLineUtils.java
@@ -28,6 +28,10 @@ public class CommandLineUtils {
     private final HashMap<String, CommandLineOption> registeredCommands = new HashMap<>();
     private List<String> commandArguments;
 
+    /**
+     * Functions for registering and command line arguments
+     */
+
     public void registerProgramName(String newProgramName) {
         programName = newProgramName;
     }
@@ -123,6 +127,10 @@ public void printHelp() {
         }
     }
 
+    /**
+     * Helper functions for registering commands
+     */
+
     public void addCommonMQTTCommands() {
         registerCommand(m_cmd_endpoint, "<str>", "The endpoint of the mqtt server, not including a port.");
         registerCommand(m_cmd_ca_file, "<path>", "Path to AmazonRootCA1.pem (optional, system trust store used by default).");
@@ -162,364 +170,496 @@ public void addCommonTopicMessageCommands()
         registerCommand(m_cmd_topic, "<str>", "Topic to publish, subscribe to. (optional, default='test/topic')");
     }
 
-    public MqttClientConnection buildCustomKeyOperationConnection(
-        MqttClientConnectionEvents callbacks, TlsContextCustomKeyOperationOptions customKeyOperationOptions)
+    public void addKeyAndCertCommands()
     {
-        try {
-            AwsIotMqttConnectionBuilder builder = AwsIotMqttConnectionBuilder.newMtlsCustomKeyOperationsBuilder(
-                customKeyOperationOptions);
-            buildConnectionSetupCAFileDefaults(builder);
-            buildConnectionSetupConnectionDefaults(builder, callbacks);
-            buildConnectionSetupProxyDefaults(builder);
-
-            MqttClientConnection conn = builder.build();
-            builder.close();
-            return conn;
-
-        } catch (CrtRuntimeException ex) {
-            return null;
-        }
+        registerCommand(m_cmd_key_file, "<path>", "Path to your key in PEM format.");
+        registerCommand(m_cmd_cert_file, "<path>", "Path to your client certificate in PEM format.");
     }
 
-    public MqttClientConnection buildPKCS11MQTTConnection(MqttClientConnectionEvents callbacks)
-    {
-        try {
-
-            Pkcs11Lib pkcs11Lib = new Pkcs11Lib(getCommandRequired(m_cmd_pkcs11_lib, ""));
-            TlsContextPkcs11Options pkcs11Options = new TlsContextPkcs11Options(pkcs11Lib);
-
-            pkcs11Options.withCertificateFilePath(getCommandRequired(m_cmd_cert_file, ""));
-            pkcs11Options.withUserPin(getCommandRequired(m_cmd_pkcs11_pin, ""));
+    /**
+     * Functions to register commands on a per-sample basis, as well as getting a struct containing all the data
+     */
 
-            if (hasCommand(m_cmd_pkcs11_token)) {
-                pkcs11Options.withTokenLabel(getCommand(m_cmd_pkcs11_token));
-            }
-
-            if (hasCommand(m_cmd_pkcs11_slot)) {
-                pkcs11Options.withSlotId(Long.parseLong(getCommand(m_cmd_pkcs11_slot)));
-            }
-
-            if (hasCommand(m_cmd_pkcs11_key)) {
-                pkcs11Options.withPrivateKeyObjectLabel(getCommand(m_cmd_pkcs11_key));
-            }
-
-            AwsIotMqttConnectionBuilder builder = AwsIotMqttConnectionBuilder.newMtlsPkcs11Builder(pkcs11Options);
-
-            buildConnectionSetupCAFileDefaults(builder);
-            buildConnectionSetupConnectionDefaults(builder, callbacks);
-
-            MqttClientConnection conn = builder.build();
-            builder.close();
-            return conn;
-
-        } catch (CrtRuntimeException ex) {
-            return null;
-        }
+    public class SampleCommandLineData
+    {
+        // General use
+        public String input_endpoint;
+        public String input_cert;
+        public String input_key;
+        public String input_ca;
+        public String input_clientId;
+        public int input_port;
+        // Proxy
+        public String input_proxyHost;
+        public int input_proxyPort;
+        // PubSub
+        public String input_topic;
+        public String input_message;
+        public int input_count;
+        // Websockets
+        public String input_signingRegion;
+        // Cognito
+        public String input_cognitoIdentity;
+        // Custom auth
+        public String input_customAuthUsername;
+        public String input_customAuthorizerName;
+        public String input_customAuthorizerSignature;
+        public String input_customAuthPassword;
+        // Fleet provisioning
+        public String input_templateName;
+        public String input_templateParameters;
+        public String input_csrPath;
+        // Services (Shadow, Jobs, Greengrass, etc)
+        public String input_thingName;
+        public String input_mode;
+        // Java Keystore
+        public String input_keystore;
+        public String input_keystorePassword;
+        public String input_keystoreFormat;
+        public String input_certificateAlias;
+        public String input_certificatePassword;
+        // Shared Subscription
+        public String input_groupIdentifier;
+        // PKCS#11
+        public String input_pkcs11LibPath;
+        public String input_pkcs11UserPin;
+        public String input_pkcs11TokenLabel;
+        public Long input_pkcs11SlotId;
+        public String input_pkcs11KeyLabel;
+        // Raw Connect
+        public String input_username;
+        public String input_password;
+        public String input_protocolName;
+        public List<String> input_authParams;
+        // X509
+        public String input_x509Endpoint;
+        public String input_x509Role;
+        public String input_x509ThingName;
+        public String input_x509Cert;
+        public String input_x509Key;
+        public String input_x509Ca;
     }
 
-    public MqttClientConnection buildWebsocketX509MQTTConnection(MqttClientConnectionEvents callbacks)
+    // Helper function for getting the message and topic
+    public void parseSampleInputPopulateMessageAndTopic(SampleCommandLineData returnData)
     {
-        try {
-
-            AwsIotMqttConnectionBuilder builder = AwsIotMqttConnectionBuilder.newMtlsBuilderFromPath(null, null);
-            buildConnectionSetupCAFileDefaults(builder);
-            buildConnectionSetupConnectionDefaults(builder, callbacks);
-
-            HttpProxyOptions proxyOptions = null;
-            int proxyPort = Integer.parseInt(getCommandOrDefault(m_cmd_proxy_port, "0"));
-            if (hasCommand(m_cmd_proxy_host) && proxyPort > 0) {
-                proxyOptions = new HttpProxyOptions();
-                proxyOptions.setHost(getCommand(m_cmd_proxy_host));
-                proxyOptions.setPort(proxyPort);
-                builder.withHttpProxyOptions(proxyOptions);
-            }
-
-            builder.withWebsockets(true);
-            builder.withWebsocketSigningRegion(getCommandRequired(m_cmd_signing_region, ""));
-
-            TlsContextOptions x509TlsOptions = TlsContextOptions.createWithMtlsFromPath(getCommandRequired(m_cmd_x509_cert_file, ""), getCommandRequired(m_cmd_x509_key_file, ""));
-            if (hasCommand(m_cmd_x509_ca_file)) {
-                x509TlsOptions.withCertificateAuthorityFromPath(null, getCommand(m_cmd_x509_ca_file));
-            }
-
-            ClientTlsContext x509TlsContext = new ClientTlsContext(x509TlsOptions);
-            X509CredentialsProvider.X509CredentialsProviderBuilder x509builder = new X509CredentialsProvider.X509CredentialsProviderBuilder()
-                .withTlsContext(x509TlsContext)
-                .withEndpoint(getCommandRequired(m_cmd_x509_endpoint, ""))
-                .withRoleAlias(getCommandRequired(m_cmd_x509_role, ""))
-                .withThingName(getCommandRequired(m_cmd_x509_thing_name, ""))
-                .withProxyOptions(proxyOptions);
-            X509CredentialsProvider provider = x509builder.build();
-            builder.withWebsocketCredentialsProvider(provider);
-
-            MqttClientConnection conn = builder.build();
-            builder.close();
-            provider.close();
-            return conn;
-
-        } catch (CrtRuntimeException ex) {
-            return null;
+        String ciPropValue = System.getProperty("aws.crt.ci");
+        boolean isCI = ciPropValue != null && Boolean.valueOf(ciPropValue);
+        if (isCI == true) {
+            returnData.input_topic = getCommandOrDefault(m_cmd_topic, "test/topic/" + UUID.randomUUID().toString());
+            returnData.input_message = getCommandOrDefault(m_cmd_message, "Hello World!");
+        } else {
+            returnData.input_topic = getCommandOrDefault(m_cmd_topic, "test/topic");
+            returnData.input_message = getCommandOrDefault(m_cmd_message, "Hello World!");
         }
     }
 
-    public MqttClientConnection buildWebsocketMQTTConnection(MqttClientConnectionEvents callbacks)
+    public SampleCommandLineData parseSampleInputBasicConnect(String[] args)
     {
-        try {
-
-            AwsIotMqttConnectionBuilder builder = AwsIotMqttConnectionBuilder.newMtlsBuilderFromPath(null, null);
-            buildConnectionSetupCAFileDefaults(builder);
-            buildConnectionSetupConnectionDefaults(builder, callbacks);
-            buildConnectionSetupProxyDefaults(builder);
-
-            builder.withWebsockets(true);
-            builder.withWebsocketSigningRegion(getCommandRequired(m_cmd_signing_region, ""));
-
-            MqttClientConnection conn = builder.build();
-            builder.close();
-            return conn;
-
-        } catch (CrtRuntimeException ex) {
-            return null;
-        }
+        addCommonMQTTCommands();
+        addCommonProxyCommands();
+        addKeyAndCertCommands();
+        registerCommand(m_cmd_client_id, "<int>", "Client id to use (optional, default='test-*').");
+        registerCommand(m_cmd_port, "<int>", "Port to connect to on the endpoint (optional, default='8883').");
+        sendArguments(args);
+
+        SampleCommandLineData returnData = new SampleCommandLineData();
+        returnData.input_endpoint = getCommandRequired(m_cmd_endpoint, "");
+        returnData.input_cert = getCommandRequired(m_cmd_cert_file, "");
+        returnData.input_key = getCommandRequired(m_cmd_key_file, "");
+        returnData.input_ca = getCommandOrDefault(m_cmd_ca_file, "");
+        returnData.input_clientId = getCommandOrDefault(m_cmd_client_id, "test-" + UUID.randomUUID().toString());
+        returnData.input_port = Integer.parseInt(getCommandOrDefault(m_cmd_port, "8883"));
+        returnData.input_proxyHost = getCommandOrDefault(m_cmd_proxy_host, "");
+        returnData.input_proxyPort = Integer.parseInt(getCommandOrDefault(m_cmd_proxy_port, "0"));
+        return returnData;
     }
 
-    public MqttClientConnection buildDirectMQTTConnection(MqttClientConnectionEvents callbacks)
+    public SampleCommandLineData parseSampleInputPubSub(String [] args)
     {
-        try {
-
-            AwsIotMqttConnectionBuilder builder = AwsIotMqttConnectionBuilder.newMtlsBuilderFromPath(
-                getCommandRequired(m_cmd_cert_file, ""), getCommandRequired(m_cmd_key_file, ""));
-            buildConnectionSetupCAFileDefaults(builder);
-            buildConnectionSetupConnectionDefaults(builder, callbacks);
-            buildConnectionSetupProxyDefaults(builder);
-
-            MqttClientConnection conn = builder.build();
-            builder.close();
-            return conn;
-        }
-        catch (CrtRuntimeException ex) {
-            return null;
-        }
+        addCommonMQTTCommands();
+        addCommonTopicMessageCommands();
+        addKeyAndCertCommands();
+        registerCommand(m_cmd_client_id, "<int>", "Client id to use (optional, default='test-*').");
+        registerCommand(m_cmd_port, "<int>", "Port to connect to on the endpoint (optional, default='8883').");
+        registerCommand(m_cmd_count, "<int>", "Number of messages to publish (optional, default='10').");
+        sendArguments(args);
+
+        SampleCommandLineData returnData = new SampleCommandLineData();
+        returnData.input_endpoint = getCommandRequired(m_cmd_endpoint, "");
+        returnData.input_cert = getCommandRequired(m_cmd_cert_file, "");
+        returnData.input_key = getCommandRequired(m_cmd_key_file, "");
+        returnData.input_ca = getCommandOrDefault(m_cmd_ca_file, "");
+        returnData.input_clientId = getCommandOrDefault(m_cmd_client_id, "test-" + UUID.randomUUID().toString());
+        returnData.input_port = Integer.parseInt(getCommandOrDefault(m_cmd_port, "8883"));
+        returnData.input_proxyHost = getCommandOrDefault(m_cmd_proxy_host, "");
+        returnData.input_proxyPort = Integer.parseInt(getCommandOrDefault(m_cmd_proxy_port, "0"));
+        parseSampleInputPopulateMessageAndTopic(returnData);
+        returnData.input_count = Integer.parseInt(getCommandOrDefault(m_cmd_count, "10"));
+        return returnData;
     }
 
-    public MqttClientConnection buildDirectMQTTConnectionWithCustomAuthorizer(MqttClientConnectionEvents callbacks)
+    public SampleCommandLineData parseSampleInputCognitoConnect(String [] args)
     {
-        try {
-            AwsIotMqttConnectionBuilder builder = AwsIotMqttConnectionBuilder.newDefaultBuilder();
-            buildConnectionSetupCAFileDefaults(builder);
-            buildConnectionSetupConnectionDefaults(builder, callbacks);
-            builder.withCustomAuthorizer(
-                getCommandOrDefault(m_cmd_custom_auth_username, null),
-                getCommandOrDefault(m_cmd_custom_auth_authorizer_name, null),
-                getCommandOrDefault(m_cmd_custom_auth_authorizer_signature, null),
-                getCommandOrDefault(m_cmd_custom_auth_password, null));
-
-            MqttClientConnection conn = builder.build();
-            builder.close();
-            return conn;
-        }
-        catch (CrtRuntimeException | UnsupportedEncodingException ex) {
-            return null;
-        }
+        addCommonMQTTCommands();
+        registerCommand(m_cmd_signing_region, "<str>", "AWS IoT service region.");
+        registerCommand(m_cmd_client_id, "<int>", "Client id to use (optional, default='test-*').");
+        registerCommand(m_cmd_cognito_identity, "<str>", "The Cognito identity ID to use to connect via Cognito");
+        sendArguments(args);
+
+        SampleCommandLineData returnData = new SampleCommandLineData();
+        returnData.input_endpoint = getCommandRequired(m_cmd_endpoint, "");
+        returnData.input_signingRegion = getCommandOrDefault(m_cmd_signing_region, "us-east-1");
+        returnData.input_clientId = getCommandOrDefault(m_cmd_client_id, "test-" + UUID.randomUUID().toString());
+        returnData.input_cognitoIdentity = getCommandRequired(m_cmd_cognito_identity, "");
+        return returnData;
     }
 
-    public MqttClientConnection buildDirectMQTTConnectionWithJavaKeystore(MqttClientConnectionEvents callbacks)
+    public SampleCommandLineData parseSampleInputCustomAuthorizerConnect(String [] args)
     {
-        try {
-            String keystoreFormat = getCommandOrDefault(m_cmd_javakeystore_format, "PKCS12");
-            java.security.KeyStore keyStore;
-            try {
-                keyStore = java.security.KeyStore.getInstance(keystoreFormat);
-            } catch (java.security.KeyStoreException ex) {
-                throw new CrtRuntimeException("Could not get instance of Java keystore with format " + keystoreFormat);
-            }
-
-            try (java.io.FileInputStream fileInputStream = new java.io.FileInputStream(getCommandRequired(m_cmd_javakeystore_path, ""))) {
-                keyStore.load(fileInputStream, getCommandRequired(m_cmd_javakeystore_password, "").toCharArray());
-            } catch (java.io.FileNotFoundException ex) {
-                throw new CrtRuntimeException("Could not open Java keystore file");
-            } catch (java.io.IOException | java.security.NoSuchAlgorithmException | java.security.cert.CertificateException ex) {
-                throw new CrtRuntimeException("Could not load Java keystore");
-            }
-
-            AwsIotMqttConnectionBuilder builder = AwsIotMqttConnectionBuilder.newJavaKeystoreBuilder(
-                keyStore,
-                getCommandRequired(m_cmd_javakeystore_certificate, ""),
-                getCommandRequired(m_cmd_javakeystore_key_password, ""));
-            buildConnectionSetupCAFileDefaults(builder);
-            buildConnectionSetupConnectionDefaults(builder, callbacks);
-            MqttClientConnection conn = builder.build();
-            builder.close();
-            return conn;
-        } catch (CrtRuntimeException ex) {
-            return null;
-        }
+        addCommonMQTTCommands();
+        registerCommand(m_cmd_client_id, "<int>", "Client id to use (optional, default='test-*').");
+        registerCommand(m_cmd_custom_auth_username, "<str>", "Username for connecting to custom authorizer (optional, default=null).");
+        registerCommand(m_cmd_custom_auth_authorizer_name, "<str>", "Name of custom authorizer (optional, default=null).");
+        registerCommand(m_cmd_custom_auth_authorizer_signature, "<str>", "Signature passed when connecting to custom authorizer (optional, default=null).");
+        registerCommand(m_cmd_custom_auth_password, "<str>", "Password for connecting to custom authorizer (optional, default=null).");
+        sendArguments(args);
+
+        SampleCommandLineData returnData = new SampleCommandLineData();
+        returnData.input_endpoint = getCommandRequired(m_cmd_endpoint, "");
+        returnData.input_clientId = getCommandOrDefault(m_cmd_client_id, "test-" + UUID.randomUUID().toString());
+        returnData.input_customAuthUsername = getCommandOrDefault(m_cmd_custom_auth_username, null);
+        returnData.input_customAuthorizerName = getCommandOrDefault(m_cmd_custom_auth_authorizer_name, null);
+        returnData.input_customAuthorizerSignature = getCommandOrDefault(m_cmd_custom_auth_authorizer_signature, null);
+        returnData.input_customAuthPassword = getCommandOrDefault(m_cmd_custom_auth_password, null);
+        return returnData;
     }
 
-    public MqttClientConnection buildCognitoMQTTConnection(MqttClientConnectionEvents callbacks)
+    public SampleCommandLineData parseSampleInputCustomKeyOpsConnect(String [] args)
     {
-        try {
-
-            AwsIotMqttConnectionBuilder builder = AwsIotMqttConnectionBuilder.newMtlsBuilderFromPath(null, null);
-            buildConnectionSetupCAFileDefaults(builder);
-            buildConnectionSetupConnectionDefaults(builder, callbacks);
-            buildConnectionSetupProxyDefaults(builder);
-
-            builder.withWebsockets(true);
-            builder.withWebsocketSigningRegion(getCommandRequired(m_cmd_signing_region, ""));
-
-            CognitoCredentialsProvider.CognitoCredentialsProviderBuilder cognitoBuilder = new CognitoCredentialsProvider.CognitoCredentialsProviderBuilder();
-            String cognitoEndpoint = "cognito-identity." + getCommandRequired(m_cmd_signing_region, "") + ".amazonaws.com";
-            cognitoBuilder.withEndpoint(cognitoEndpoint).withIdentity(getCommandRequired(m_cmd_cognito_identity, ""));
-            cognitoBuilder.withClientBootstrap(ClientBootstrap.getOrCreateStaticDefault());
-
-            TlsContextOptions cognitoTlsContextOptions = TlsContextOptions.createDefaultClient();
-            ClientTlsContext cognitoTlsContext = new ClientTlsContext(cognitoTlsContextOptions);
-            cognitoTlsContextOptions.close();
-            cognitoBuilder.withTlsContext(cognitoTlsContext);
-
-            CognitoCredentialsProvider cognitoCredentials = cognitoBuilder.build();
-            builder.withWebsocketCredentialsProvider(cognitoCredentials);
-
-            MqttClientConnection conn = builder.build();
-            builder.close();
-            cognitoCredentials.close();
-            cognitoTlsContext.close();
-            return conn;
-
-        } catch (CrtRuntimeException ex) {
-            return null;
-        }
+        addCommonMQTTCommands();
+        addKeyAndCertCommands();
+        registerCommand(m_cmd_client_id, "<int>", "Client id to use (optional, default='test-*').");
+        registerCommand(m_cmd_port, "<int>", "Port to connect to on the endpoint (optional, default='8883').");
+        sendArguments(args);
+
+        SampleCommandLineData returnData = new SampleCommandLineData();
+        returnData.input_endpoint = getCommandRequired(m_cmd_endpoint, "");
+        returnData.input_cert = getCommandRequired(m_cmd_cert_file, "");
+        returnData.input_key = getCommandRequired(m_cmd_key_file, "");
+        returnData.input_ca = getCommandOrDefault(m_cmd_ca_file, "");
+        returnData.input_clientId = getCommandOrDefault(m_cmd_client_id, "test-" + UUID.randomUUID().toString());
+        returnData.input_port = Integer.parseInt(getCommandOrDefault(m_cmd_port, "8883"));
+        return returnData;
     }
 
-    public Mqtt5Client buildWebsocketMQTT5Connection(
-        Mqtt5ClientOptions.LifecycleEvents lifecycleEvents, Mqtt5ClientOptions.PublishEvents publishEvents) {
-        try {
-
-            AwsIotMqtt5ClientBuilder.WebsocketSigv4Config websocketConfig = new AwsIotMqtt5ClientBuilder.WebsocketSigv4Config();
-            if (hasCommand(m_cmd_signing_region)) {
-                websocketConfig.region = getCommandRequired(m_cmd_signing_region, "");
-            }
-            AwsIotMqtt5ClientBuilder builder = AwsIotMqtt5ClientBuilder.newWebsocketMqttBuilderWithSigv4Auth(
-                getCommandRequired(m_cmd_endpoint, ""), websocketConfig);
-
-            ConnectPacket.ConnectPacketBuilder connectProperties = new ConnectPacket.ConnectPacketBuilder();
-            connectProperties.withClientId(getCommandOrDefault("client_id", "test-" + UUID.randomUUID().toString()));
-            builder.withConnectProperties(connectProperties);
-
-            builder.withLifeCycleEvents(lifecycleEvents);
-            builder.withPublishEvents(publishEvents);
+    public SampleCommandLineData parseSampleInputFleetProvisioning(String [] args)
+    {
+        addCommonMQTTCommands();
+        addKeyAndCertCommands();
+        registerCommand(m_cmd_client_id, "<int>", "Client id to use (optional, default='test-*').");
+        registerCommand(m_cmd_port, "<int>", "Port to connect to on the endpoint (optional, default='8883').");
+        registerCommand(m_cmd_fleet_template_name, "<str>", "Provisioning template name.");
+        registerCommand(m_cmd_fleet_template_parameters, "<json>", "Provisioning template parameters.");
+        registerCommand(m_cmd_fleet_template_csr, "<path>", "Path to the CSR file (optional).");
+        sendArguments(args);
+
+        SampleCommandLineData returnData = new SampleCommandLineData();
+        returnData.input_endpoint = getCommandRequired(m_cmd_endpoint, "");
+        returnData.input_cert = getCommandRequired(m_cmd_cert_file, "");
+        returnData.input_key = getCommandRequired(m_cmd_key_file, "");
+        returnData.input_ca = getCommandOrDefault(m_cmd_ca_file, "");
+        returnData.input_clientId = getCommandOrDefault(m_cmd_client_id, "test-" + UUID.randomUUID().toString());
+        returnData.input_port = Integer.parseInt(getCommandOrDefault(m_cmd_port, "8883"));
+        returnData.input_templateName = getCommandRequired(m_cmd_fleet_template_name, "");
+        returnData.input_templateParameters = getCommandRequired(m_cmd_fleet_template_parameters, "");
+        returnData.input_csrPath = getCommandOrDefault(m_cmd_fleet_template_csr, null);
+        return returnData;
+    }
 
-            Mqtt5Client returnClient = builder.build();
-            builder.close();
-            return returnClient;
+    public SampleCommandLineData parseSampleInputGreengrassDiscovery(String [] args)
+    {
+        addCommonMQTTCommands();
+        removeCommand(m_cmd_endpoint);
+        addKeyAndCertCommands();
+        registerCommand(m_cmd_signing_region, "<str>", "AWS IoT service region (optional, default='us-east-1').");
+        registerCommand(m_cmd_thing_name, "<str>", "The name of the IoT thing.");
+        registerCommand(m_cmd_topic, "<str>", "Topic to subscribe/publish to (optional, default='test/topic').");
+        registerCommand(m_cmd_mode, "<str>", "Mode options: 'both', 'publish', or 'subscribe' (optional, default='both').");
+        addCommonProxyCommands();
+        sendArguments(args);
+
+        SampleCommandLineData returnData = new SampleCommandLineData();
+        returnData.input_thingName = getCommandRequired(m_cmd_thing_name, "");
+        returnData.input_signingRegion = getCommandOrDefault(m_cmd_signing_region, "us-east-1");
+        returnData.input_ca = getCommandOrDefault(m_cmd_ca_file, null);
+        returnData.input_cert = getCommandRequired(m_cmd_cert_file, "");
+        returnData.input_key = getCommandRequired(m_cmd_key_file, "");
+        returnData.input_proxyHost = getCommandOrDefault(m_cmd_proxy_host, "");
+        returnData.input_proxyPort = Integer.parseInt(getCommandOrDefault(m_cmd_proxy_port, "0"));
+        returnData.input_topic = getCommandOrDefault(m_cmd_topic, "test/topic");
+        returnData.input_mode = getCommandOrDefault(m_cmd_mode, "Hello World!");
+        return returnData;
+    }
 
-        } catch (CrtRuntimeException ex) {
-            return null;
-        }
+    public SampleCommandLineData parseSampleInputKeystoreConnect(String [] args)
+    {
+        addCommonMQTTCommands();
+        addCommonProxyCommands();
+        registerCommand(m_cmd_javakeystore_path, "<file>", "The path to the Java keystore to use");
+        registerCommand(m_cmd_javakeystore_password, "<str>", "The password for the Java keystore");
+        registerCommand(m_cmd_javakeystore_format, "<str>", "The format of the Java keystore (optional, default='PKCS12')");
+        registerCommand(m_cmd_javakeystore_certificate, "<str>", "The certificate alias to use to access the key and certificate in the Java keystore");
+        registerCommand(m_cmd_javakeystore_key_password, "<str>", "The password associated with the key and certificate in the Java keystore");
+        registerCommand(m_cmd_client_id, "<int>", "Client id to use (optional, default='test-*').");
+        registerCommand(m_cmd_port, "<int>", "Port to connect to on the endpoint (optional, default='8883').");
+        sendArguments(args);
+
+        SampleCommandLineData returnData = new SampleCommandLineData();
+        returnData.input_endpoint = getCommandRequired(m_cmd_endpoint, "");
+        returnData.input_ca = getCommandOrDefault(m_cmd_ca_file, "");
+        returnData.input_clientId = getCommandOrDefault(m_cmd_client_id, "test-" + UUID.randomUUID().toString());
+        returnData.input_port = Integer.parseInt(getCommandOrDefault(m_cmd_port, "8883"));
+        returnData.input_proxyHost = getCommandOrDefault(m_cmd_proxy_host, "");
+        returnData.input_proxyPort = Integer.parseInt(getCommandOrDefault(m_cmd_proxy_port, "0"));
+        returnData.input_keystore = getCommandRequired(m_cmd_javakeystore_path, "");
+        returnData.input_keystorePassword = getCommandRequired(m_cmd_javakeystore_password, "");
+        returnData.input_keystoreFormat = getCommandOrDefault(m_cmd_javakeystore_format, "PKCS12");
+        returnData.input_certificateAlias = getCommandRequired(m_cmd_javakeystore_certificate, "");
+        returnData.input_certificatePassword = getCommandRequired(m_cmd_javakeystore_key_password, "");
+        return returnData;
     }
 
-    public Mqtt5Client buildDirectMQTT5Connection(
-        Mqtt5ClientOptions.LifecycleEvents lifecycleEvents, Mqtt5ClientOptions.PublishEvents publishEvents) {
-        try {
-            AwsIotMqtt5ClientBuilder builder = AwsIotMqtt5ClientBuilder.newDirectMqttBuilderWithMtlsFromPath(
-                getCommandRequired(m_cmd_endpoint, ""), getCommandRequired(m_cmd_cert_file, ""), getCommandRequired(m_cmd_key_file, ""));
+    public SampleCommandLineData parseSampleInputJobs(String[] args)
+    {
+        addCommonMQTTCommands();
+        addKeyAndCertCommands();
+        registerCommand(m_cmd_client_id, "<int>", "Client id to use (optional, default='test-*').");
+        registerCommand(m_cmd_port, "<int>", "Port to connect to on the endpoint (optional, default='8883').");
+        registerCommand(m_cmd_thing_name, "<str>", "The name of the IoT thing.");
+        sendArguments(args);
+
+        SampleCommandLineData returnData = new SampleCommandLineData();
+        returnData.input_endpoint = getCommandRequired(m_cmd_endpoint, "");
+        returnData.input_cert = getCommandRequired(m_cmd_cert_file, "");
+        returnData.input_key = getCommandRequired(m_cmd_key_file, "");
+        returnData.input_ca = getCommandOrDefault(m_cmd_ca_file, "");
+        returnData.input_clientId = getCommandOrDefault(m_cmd_client_id, "test-" + UUID.randomUUID().toString());
+        returnData.input_port = Integer.parseInt(getCommandOrDefault(m_cmd_port, "8883"));
+        returnData.input_thingName = getCommandRequired(m_cmd_thing_name, "");
+        return returnData;
+    }
 
-            ConnectPacket.ConnectPacketBuilder connectProperties = new ConnectPacket.ConnectPacketBuilder();
-            connectProperties.withClientId(getCommandOrDefault("client_id", "test-" + UUID.randomUUID().toString()));
-            builder.withConnectProperties(connectProperties);
+    public SampleCommandLineData parseSampleInputMqtt5PubSub(String [] args)
+    {
+        addCommonMQTTCommands();
+        addCommonTopicMessageCommands();
+        addKeyAndCertCommands();
+        registerCommand(m_cmd_client_id, "<int>", "Client id to use (optional, default='test-*').");
+        registerCommand(m_cmd_port, "<int>", "Port to connect to on the endpoint (optional, default='8883').");
+        registerCommand(m_cmd_count, "<int>", "Number of messages to publish (optional, default='10').");
+        registerCommand(m_cmd_signing_region, "<string>", "Websocket region to use (will use websockets to connect if defined).");
+        sendArguments(args);
+
+        SampleCommandLineData returnData = new SampleCommandLineData();
+        returnData.input_endpoint = getCommandRequired(m_cmd_endpoint, "");
+        returnData.input_cert = getCommandRequired(m_cmd_cert_file, "");
+        returnData.input_key = getCommandRequired(m_cmd_key_file, "");
+        returnData.input_ca = getCommandOrDefault(m_cmd_ca_file, "");
+        returnData.input_clientId = getCommandOrDefault(m_cmd_client_id, "test-" + UUID.randomUUID().toString());
+        returnData.input_port = Integer.parseInt(getCommandOrDefault(m_cmd_port, "8883"));
+        returnData.input_proxyHost = getCommandOrDefault(m_cmd_proxy_host, "");
+        returnData.input_proxyPort = Integer.parseInt(getCommandOrDefault(m_cmd_proxy_port, "0"));
+        parseSampleInputPopulateMessageAndTopic(returnData);
+        returnData.input_count = Integer.parseInt(getCommandOrDefault(m_cmd_count, "10"));
+        returnData.input_signingRegion = getCommandOrDefault(m_cmd_signing_region, null);
+        return returnData;
+    }
 
-            builder.withLifeCycleEvents(lifecycleEvents);
-            builder.withPublishEvents(publishEvents);
+    public SampleCommandLineData parseSampleInputMqtt5SharedSubscription(String [] args)
+    {
+        addCommonMQTTCommands();
+        addCommonTopicMessageCommands();
+        addKeyAndCertCommands();
+        registerCommand(m_cmd_client_id, "<int>", "Client id to use (optional, default='test-*').");
+        registerCommand(m_cmd_port, "<int>", "Port to connect to on the endpoint (optional, default='8883').");
+        registerCommand(m_cmd_count, "<int>", "Number of messages to publish (optional, default='10').");
+        registerCommand(m_cmd_group_identifier, "<string>", "The group identifier to use in the shared subscription (optional, default='java-sample')");
+        sendArguments(args);
+
+        SampleCommandLineData returnData = new SampleCommandLineData();
+        returnData.input_endpoint = getCommandRequired(m_cmd_endpoint, "");
+        returnData.input_cert = getCommandRequired(m_cmd_cert_file, "");
+        returnData.input_key = getCommandRequired(m_cmd_key_file, "");
+        returnData.input_ca = getCommandOrDefault(m_cmd_ca_file, "");
+        returnData.input_clientId = getCommandOrDefault(m_cmd_client_id, "test-" + UUID.randomUUID().toString());
+        returnData.input_port = Integer.parseInt(getCommandOrDefault(m_cmd_port, "8883"));
+        returnData.input_proxyHost = getCommandOrDefault(m_cmd_proxy_host, "");
+        returnData.input_proxyPort = Integer.parseInt(getCommandOrDefault(m_cmd_proxy_port, "0"));
+        parseSampleInputPopulateMessageAndTopic(returnData);
+        returnData.input_count = Integer.parseInt(getCommandOrDefault(m_cmd_count, "10"));
+        returnData.input_groupIdentifier = getCommandOrDefault(m_cmd_group_identifier, "java-sample");
+        return returnData;
+    }
 
-            Mqtt5Client returnClient = builder.build();
-            builder.close();
-            return returnClient;
-        }
-        catch (CrtRuntimeException ex) {
-            return null;
+    public SampleCommandLineData parseSampleInputPkcs11Connect(String [] args)
+    {
+        addCommonMQTTCommands();
+        registerCommand(m_cmd_cert_file, "<path>", "Path to your client certificate in PEM format.");
+        registerCommand(m_cmd_client_id, "<int>", "Client id to use (optional, default='test-*').");
+        registerCommand(m_cmd_port, "<int>", "Port to connect to on the endpoint (optional, default='8883').");
+        registerCommand(m_cmd_pkcs11_lib, "<path>", "Path to PKCS#11 library.");
+        registerCommand(m_cmd_pkcs11_pin, "<int>", "User PIN for logging into PKCS#11 token.");
+        registerCommand(m_cmd_pkcs11_token, "<str>", "Label of PKCS#11 token to use (optional).");
+        registerCommand(m_cmd_pkcs11_slot, "<int>", "Slot ID containing PKCS#11 token to use (optional).");
+        registerCommand(m_cmd_pkcs11_key, "<str>", "Label of private key on the PKCS#11 token (optional).");
+        sendArguments(args);
+
+        SampleCommandLineData returnData = new SampleCommandLineData();
+        returnData.input_endpoint = getCommandRequired(m_cmd_endpoint, "");
+        returnData.input_cert = getCommandRequired(m_cmd_cert_file, "");
+        returnData.input_ca = getCommandOrDefault(m_cmd_ca_file, "");
+        returnData.input_clientId = getCommandOrDefault(m_cmd_client_id, "test-" + UUID.randomUUID().toString());
+        returnData.input_port = Integer.parseInt(getCommandOrDefault(m_cmd_port, "8883"));
+        returnData.input_pkcs11LibPath = getCommandRequired(m_cmd_pkcs11_lib, "");
+        returnData.input_pkcs11UserPin = getCommandRequired(m_cmd_pkcs11_pin, "");
+        returnData.input_pkcs11TokenLabel = getCommandOrDefault(m_cmd_pkcs11_token, "");
+        returnData.input_pkcs11SlotId = null;
+        if (hasCommand(m_cmd_pkcs11_slot)) {
+            returnData.input_pkcs11SlotId = Long.parseLong(getCommandOrDefault(m_cmd_pkcs11_slot, "-1"));
         }
+        returnData.input_pkcs11KeyLabel = getCommandOrDefault(m_cmd_pkcs11_key, "");
+        return returnData;
     }
 
-    private void buildConnectionSetupCAFileDefaults(AwsIotMqttConnectionBuilder builder)
+    public SampleCommandLineData parseSampleInputShadow(String [] args)
     {
-        if (hasCommand(m_cmd_ca_file)) {
-            builder.withCertificateAuthorityFromPath(null, getCommand(m_cmd_ca_file));
-        }
+        // Shadow and Jobs use the same inputs currently
+        return parseSampleInputJobs(args);
     }
-    private void buildConnectionSetupConnectionDefaults(AwsIotMqttConnectionBuilder builder, MqttClientConnectionEvents callbacks)
+
+    public SampleCommandLineData parseSampleInputWebsocketConnect(String [] args)
     {
-        builder.withConnectionEventCallbacks(callbacks)
-                .withClientId(getCommandOrDefault("client_id", "test-" + UUID.randomUUID().toString()))
-                .withEndpoint(getCommandRequired(m_cmd_endpoint, ""))
-                .withPort((short) Integer.parseInt(getCommandOrDefault("port", "8883")) )
-                .withCleanSession(true)
-                .withProtocolOperationTimeoutMs(60000);
-    }
-    private void buildConnectionSetupProxyDefaults(AwsIotMqttConnectionBuilder builder)
+        addCommonMQTTCommands();
+        addCommonProxyCommands();
+        registerCommand(m_cmd_signing_region, "<str>", "AWS IoT service region.");
+        registerCommand(m_cmd_client_id, "<int>", "Client id to use (optional, default='test-*').");
+        registerCommand(m_cmd_port, "<int>", "Port to connect to on the endpoint (optional, default='443').");
+        sendArguments(args);
+
+        SampleCommandLineData returnData = new SampleCommandLineData();
+        returnData.input_endpoint = getCommandRequired(m_cmd_endpoint, "");
+        returnData.input_ca = getCommandOrDefault(m_cmd_ca_file, "");
+        returnData.input_signingRegion = getCommandRequired(m_cmd_signing_region, "");
+        returnData.input_clientId = getCommandOrDefault(m_cmd_client_id, "test-" + UUID.randomUUID().toString());
+        returnData.input_port = Integer.parseInt(getCommandOrDefault(m_cmd_port, "443"));
+        returnData.input_proxyHost = getCommandOrDefault(m_cmd_proxy_host, "");
+        returnData.input_proxyPort = Integer.parseInt(getCommandOrDefault(m_cmd_proxy_port, "0"));
+        return returnData;
+    }
+
+    public SampleCommandLineData parseSampleInputWindowsCertConnect(String [] args)
     {
-        int proxyPort = Integer.parseInt(getCommandOrDefault(m_cmd_proxy_port, "0"));
-        if (hasCommand(m_cmd_proxy_host) && proxyPort > 0) {
-            HttpProxyOptions proxyOptions = new HttpProxyOptions();
-            proxyOptions.setHost(getCommand(m_cmd_proxy_host));
-            proxyOptions.setPort(proxyPort);
-            builder.withHttpProxyOptions(proxyOptions);
-        }
+        addCommonMQTTCommands();
+        registerCommand(m_cmd_cert_file, "<str>", "Path to certificate in Windows cert store. " +
+                                                  "e.g. \"CurrentUser\\MY\\6ac133ac58f0a88b83e9c794eba156a98da39b4c\"");
+        registerCommand(m_cmd_client_id, "<int>", "Client id to use (optional, default='test-*').");
+        registerCommand(m_cmd_port, "<int>", "Port to connect to on the endpoint (optional, default='8883').");
+        sendArguments(args);
+
+        SampleCommandLineData returnData = new SampleCommandLineData();
+        returnData.input_endpoint = getCommandRequired("endpoint", "");
+        returnData.input_cert = getCommandRequired("cert", "");
+        returnData.input_ca = getCommandOrDefault("ca", "");
+        returnData.input_clientId = getCommandOrDefault("client_id", "test-" + UUID.randomUUID().toString());
+        returnData.input_port = Integer.parseInt(getCommandOrDefault("port", "8883"));
+        return returnData;
     }
 
-    public MqttClientConnection buildMQTTConnection(MqttClientConnectionEvents callbacks)
+    public SampleCommandLineData parseSampleInputX509Connect(String [] args)
     {
-        if (hasCommand(m_cmd_pkcs11_lib))
-        {
-            return buildPKCS11MQTTConnection(callbacks);
-        }
-        else if (hasCommand(m_cmd_signing_region))
-        {
-            if (hasCommand(m_cmd_x509_endpoint))
-            {
-                return buildWebsocketX509MQTTConnection(callbacks);
-            }
-            else
-            {
-                return buildWebsocketMQTTConnection(callbacks);
-            }
-        }
-        else if (hasCommand(m_cmd_custom_auth_authorizer_name))
-        {
-            return buildDirectMQTTConnectionWithCustomAuthorizer(callbacks);
-        }
-        else
-        {
-            return buildDirectMQTTConnection(callbacks);
-        }
+        addCommonMQTTCommands();
+        addCommonProxyCommands();
+        addCommonX509Commands();
+        registerCommand(m_cmd_signing_region, "<str>", "AWS IoT service region.");
+        registerCommand(m_cmd_client_id, "<int>", "Client id to use (optional, default='test-*').");
+        registerCommand(m_cmd_port, "<int>", "Port to connect to on the endpoint (optional, default='8883').");
+        sendArguments(args);
+
+        /**
+         * Gather the input from the command line
+         */
+        SampleCommandLineData returnData = new SampleCommandLineData();
+        returnData.input_endpoint = getCommandRequired(m_cmd_endpoint, "");
+        returnData.input_ca = getCommandOrDefault(m_cmd_ca_file, "");
+        returnData.input_signingRegion = getCommandRequired(m_cmd_signing_region, "");
+        returnData.input_clientId = getCommandOrDefault(m_cmd_client_id, "test-" + UUID.randomUUID().toString());
+        returnData.input_port = Integer.parseInt(getCommandOrDefault(m_cmd_port, "443"));
+        returnData.input_proxyHost = getCommandOrDefault(m_cmd_proxy_host, "");
+        returnData.input_proxyPort = Integer.parseInt(getCommandOrDefault(m_cmd_proxy_port, "0"));
+        returnData.input_x509Endpoint = getCommandRequired(m_cmd_x509_endpoint, "");
+        returnData.input_x509Role = getCommandRequired(m_cmd_x509_role, "");
+        returnData.input_x509ThingName = getCommandRequired(m_cmd_x509_thing_name, "");
+        returnData.input_x509Cert = getCommandRequired(m_cmd_x509_cert_file, "");
+        returnData.input_x509Key = getCommandRequired(m_cmd_x509_key_file, "");
+        returnData.input_x509Ca = getCommandOrDefault(m_cmd_x509_ca_file, null);
+        return returnData;
     }
 
-    public void sampleConnectAndDisconnect(MqttClientConnection connection) throws CrtRuntimeException, InterruptedException, ExecutionException
+    /**
+     * Based on the sample string: sets up the arguments, parses the arguments, and returns the command line data all in one go
+     */
+    public static SampleCommandLineData getInputForIoTSample(String sampleName, String[] args)
     {
-        try {
-            // Connect and disconnect
-            CompletableFuture<Boolean> connected = connection.connect();
-            try {
-                boolean sessionPresent = connected.get();
-                System.out.println("Connected to " + (!sessionPresent ? "new" : "existing") + " session!");
-            } catch (Exception ex) {
-                throw new RuntimeException("Exception occurred during connect", ex);
-            }
-            System.out.println("Disconnecting...");
-            CompletableFuture<Void> disconnected = connection.disconnect();
-            disconnected.get();
-            System.out.println("Disconnected.");
-        }
-        catch (CrtRuntimeException | InterruptedException | ExecutionException ex) {
-            throw ex;
+        CommandLineUtils cmdUtils = new CommandLineUtils();
+        cmdUtils.registerProgramName(sampleName);
+
+        if (sampleName.equals("BasicConnect")) {
+            return cmdUtils.parseSampleInputBasicConnect(args);
+        } else if (sampleName.equals("PubSub")) {
+            return cmdUtils.parseSampleInputPubSub(args);
+        } else if (sampleName.equals("CognitoConnect")) {
+            return cmdUtils.parseSampleInputCognitoConnect(args);
+        } else if (sampleName.equals("CustomAuthorizerConnect")) {
+            return cmdUtils.parseSampleInputCustomAuthorizerConnect(args);
+        } else if (sampleName.equals("CustomKeyOpsConnect")) {
+            return cmdUtils.parseSampleInputCustomKeyOpsConnect(args);
+        } else if (sampleName.equals("FleetProvisioningSample")) {
+            return cmdUtils.parseSampleInputFleetProvisioning(args);
+        } else if (sampleName.equals("BasicDiscovery")) {
+            return cmdUtils.parseSampleInputGreengrassDiscovery(args);
+        } else if (sampleName.equals("JavaKeystoreConnect")) {
+            return cmdUtils.parseSampleInputKeystoreConnect(args);
+        } else if (sampleName.equals("Jobs")) {
+            return cmdUtils.parseSampleInputJobs(args);
+        } else if (sampleName.equals("Mqtt5PubSub")) {
+            return cmdUtils.parseSampleInputMqtt5PubSub(args);
+        } else if (sampleName.equals("Mqtt5SharedSubscription")) {
+            return cmdUtils.parseSampleInputMqtt5SharedSubscription(args);
+        } else if (sampleName.equals("Pkcs11Connect")) {
+            return cmdUtils.parseSampleInputPkcs11Connect(args);
+        } else if (sampleName.equals("Shadow")) {
+            return cmdUtils.parseSampleInputShadow(args);
+        } else if (sampleName.equals("WebsocketConnect")) {
+            return cmdUtils.parseSampleInputWebsocketConnect(args);
+        } else if (sampleName.equals("WindowsCertConnect")) {
+            return cmdUtils.parseSampleInputWindowsCertConnect(args);
+        } else if (sampleName.equals("x509CredentialsProviderConnect")) {
+            return cmdUtils.parseSampleInputX509Connect(args);
+        } else {
+            throw new RuntimeException("Unknown sample name!");
         }
     }
 
-    // Constants for commonly used/needed commands
+    /**
+     * Constants for commonly used/needed commands
+     */
     private static final String m_cmd_endpoint = "endpoint";
     private static final String m_cmd_ca_file = "ca_file";
     private static final String m_cmd_cert_file = "cert";
     private static final String m_cmd_key_file = "key";
+    private static final String m_cmd_client_id = "client_id";
+    private static final String m_cmd_port = "port";
     private static final String m_cmd_proxy_host = "proxy_host";
     private static final String m_cmd_proxy_port = "proxy_port";
     private static final String m_cmd_signing_region = "signing_region";
@@ -531,7 +671,7 @@ public void sampleConnectAndDisconnect(MqttClientConnection connection) throws C
     private static final String m_cmd_x509_ca_file = "x509_ca_file";
     private static final String m_cmd_pkcs11_lib = "pkcs11_lib";
     private static final String m_cmd_pkcs11_cert = "cert";
-    private static final String m_cmd_pkcs11_pin = "ppin";
+    private static final String m_cmd_pkcs11_pin = "pin";
     private static final String m_cmd_pkcs11_token = "token_label";
     private static final String m_cmd_pkcs11_slot = "slot_id";
     private static final String m_cmd_pkcs11_key = "key_label";
@@ -548,6 +688,17 @@ public void sampleConnectAndDisconnect(MqttClientConnection connection) throws C
     private static final String m_cmd_javakeystore_certificate = "certificate_alias";
     private static final String m_cmd_javakeystore_key_password = "certificate_password";
     private static final String m_cmd_cognito_identity = "cognito_identity";
+    private static final String m_cmd_count = "count";
+    private static final String m_cmd_fleet_template_name = "template_name";
+    private static final String m_cmd_fleet_template_parameters = "template_parameters";
+    private static final String m_cmd_fleet_template_csr = "csr";
+    private static final String m_cmd_thing_name = "thing_name";
+    private static final String m_cmd_mode = "mode";
+    private static final String m_cmd_group_identifier = "group_identifier";
+    private static final String m_cmd_username = "username";
+    private static final String m_cmd_password = "password";
+    private static final String m_cmd_protocol = "protocol";
+    private static final String m_cmd_auth_params = "auth_params";
 }
 
 class CommandLineOption {
diff --git a/samples/WebsocketConnect/src/main/java/websocketconnect/WebsocketConnect.java b/samples/WebsocketConnect/src/main/java/websocketconnect/WebsocketConnect.java
index 5b980b3d0..a2f94bdc6 100644
--- a/samples/WebsocketConnect/src/main/java/websocketconnect/WebsocketConnect.java
+++ b/samples/WebsocketConnect/src/main/java/websocketconnect/WebsocketConnect.java
@@ -10,9 +10,11 @@
 import software.amazon.awssdk.crt.CrtRuntimeException;
 import software.amazon.awssdk.crt.mqtt.MqttClientConnection;
 import software.amazon.awssdk.crt.mqtt.MqttClientConnectionEvents;
-import software.amazon.awssdk.iot.iotjobs.model.RejectedError;
+import software.amazon.awssdk.crt.http.HttpProxyOptions;
+import software.amazon.awssdk.iot.AwsIotMqttConnectionBuilder;
 
 import java.util.concurrent.ExecutionException;
+import java.util.concurrent.CompletableFuture;
 
 import utils.commandlineutils.CommandLineUtils;
 
@@ -39,14 +41,12 @@ static void onApplicationFailure(Throwable cause) {
 
     public static void main(String[] args) {
 
-        cmdUtils = new CommandLineUtils();
-        cmdUtils.registerProgramName("WebsocketConnect");
-        cmdUtils.addCommonMQTTCommands();
-        cmdUtils.addCommonProxyCommands();
-        cmdUtils.registerCommand("signing_region", "<str>", "AWS IoT service region.");
-        cmdUtils.registerCommand("client_id", "<int>", "Client id to use (optional, default='test-*').");
-        cmdUtils.registerCommand("port", "<int>", "Port to connect to on the endpoint (optional, default='8883').");
-        cmdUtils.sendArguments(args);
+        /**
+         * cmdData is the arguments/input from the command line placed into a single struct for
+         * use in this sample. This handles all of the command line parsing, validating, etc.
+         * See the Utils/CommandLineUtils for more information.
+         */
+        CommandLineUtils.SampleCommandLineData cmdData = CommandLineUtils.getInputForIoTSample("WebsocketConnect", args);
 
         MqttClientConnectionEvents callbacks = new MqttClientConnectionEvents() {
             @Override
@@ -63,20 +63,53 @@ public void onConnectionResumed(boolean sessionPresent) {
         };
 
         try {
+
             /**
-             * Creates a websocket connection using AWS credentials on the device.
-             * Note: The data for the connection is gotten from cmdUtils.
-             * (see buildWebsocketMQTTConnection for implementation)
+             * Create the MQTT connection from the builder
+             */
+            AwsIotMqttConnectionBuilder builder = AwsIotMqttConnectionBuilder.newMtlsBuilderFromPath(null, null);
+            if (cmdData.input_ca != "") {
+                builder.withCertificateAuthorityFromPath(null, cmdData.input_ca);
+            }
+            builder.withConnectionEventCallbacks(callbacks)
+                .withClientId(cmdData.input_clientId)
+                .withEndpoint(cmdData.input_endpoint)
+                .withPort((short)cmdData.input_port)
+                .withCleanSession(true)
+                .withProtocolOperationTimeoutMs(60000);
+            if (cmdData.input_proxyHost != "" && cmdData.input_proxyPort > 0) {
+                HttpProxyOptions proxyOptions = new HttpProxyOptions();
+                proxyOptions.setHost(cmdData.input_proxyHost);
+                proxyOptions.setPort(cmdData.input_proxyPort);
+                builder.withHttpProxyOptions(proxyOptions);
+            }
+            builder.withWebsockets(true);
+            builder.withWebsocketSigningRegion(cmdData.input_signingRegion);
+            MqttClientConnection connection = builder.build();
+            builder.close();
+
+            /**
+             * Verify the connection was created
              */
-            MqttClientConnection connection = cmdUtils.buildWebsocketMQTTConnection(callbacks);
             if (connection == null)
             {
                 onApplicationFailure(new RuntimeException("MQTT connection creation failed!"));
             }
 
-            // Connect and disconnect using the connection we created
-            // (see sampleConnectAndDisconnect for implementation)
-            cmdUtils.sampleConnectAndDisconnect(connection);
+            /**
+             * Connect and disconnect
+             */
+            CompletableFuture<Boolean> connected = connection.connect();
+            try {
+                boolean sessionPresent = connected.get();
+                System.out.println("Connected to " + (!sessionPresent ? "new" : "existing") + " session!");
+            } catch (Exception ex) {
+                throw new RuntimeException("Exception occurred during connect", ex);
+            }
+            System.out.println("Disconnecting...");
+            CompletableFuture<Void> disconnected = connection.disconnect();
+            disconnected.get();
+            System.out.println("Disconnected.");
 
             // Close the connection now that we are completely done with it.
             connection.close();
diff --git a/samples/WindowsCertConnect/src/main/java/windowscertconnect/WindowsCertConnect.java b/samples/WindowsCertConnect/src/main/java/windowscertconnect/WindowsCertConnect.java
index 2bae93619..96b77f63a 100644
--- a/samples/WindowsCertConnect/src/main/java/windowscertconnect/WindowsCertConnect.java
+++ b/samples/WindowsCertConnect/src/main/java/windowscertconnect/WindowsCertConnect.java
@@ -10,10 +10,7 @@
 import software.amazon.awssdk.crt.mqtt.*;
 import software.amazon.awssdk.iot.AwsIotMqttConnectionBuilder;
 
-import java.nio.charset.StandardCharsets;
-import java.util.UUID;
 import java.util.concurrent.CompletableFuture;
-import java.util.concurrent.CountDownLatch;
 import java.util.concurrent.ExecutionException;
 
 import utils.commandlineutils.CommandLineUtils;
@@ -43,21 +40,12 @@ static void onApplicationFailure(Throwable cause) {
 
     public static void main(String[] args) {
 
-        cmdUtils = new CommandLineUtils();
-        cmdUtils.registerProgramName("WindowsCertConnect");
-        cmdUtils.addCommonMQTTCommands();
-        cmdUtils.registerCommand("cert", "<str>", "Path to certificate in Windows cert store. " +
-                                                  "e.g. \"CurrentUser\\MY\\6ac133ac58f0a88b83e9c794eba156a98da39b4c\"");
-        cmdUtils.registerCommand("client_id", "<int>", "Client id to use (optional, default='test-*').");
-        cmdUtils.registerCommand("port", "<int>", "Port to connect to on the endpoint (optional, default='8883').");
-        cmdUtils.registerCommand("help", "", "Prints this message");
-        cmdUtils.sendArguments(args);
-
-        String endpoint = cmdUtils.getCommandRequired("endpoint", "");
-        String windowsCertStorePath = cmdUtils.getCommandRequired("cert", "");
-        String rootCaPath = cmdUtils.getCommandOrDefault("ca_file", "");
-        String clientId = cmdUtils.getCommandOrDefault("client_id", "test-" + UUID.randomUUID().toString());
-        int port = Integer.parseInt(cmdUtils.getCommandOrDefault("port", "8883"));
+        /**
+         * cmdData is the arguments/input from the command line placed into a single struct for
+         * use in this sample. This handles all of the command line parsing, validating, etc.
+         * See the Utils/CommandLineUtils for more information.
+         */
+        CommandLineUtils.SampleCommandLineData cmdData = CommandLineUtils.getInputForIoTSample("WindowsCertConnect", args);
 
         MqttClientConnectionEvents callbacks = new MqttClientConnectionEvents() {
             @Override
@@ -73,28 +61,48 @@ public void onConnectionResumed(boolean sessionPresent) {
             }
         };
 
-        try (AwsIotMqttConnectionBuilder builder =
-                AwsIotMqttConnectionBuilder.newMtlsWindowsCertStorePathBuilder(windowsCertStorePath)) {
-
-            if (rootCaPath != null && rootCaPath != "") {
-                builder.withCertificateAuthorityFromPath(null, rootCaPath);
+        try {
+            AwsIotMqttConnectionBuilder builder = AwsIotMqttConnectionBuilder.newMtlsWindowsCertStorePathBuilder(cmdData.input_cert);
+            if (cmdData.input_ca != "") {
+                builder.withCertificateAuthorityFromPath(null, cmdData.input_ca);
             }
-
             builder.withConnectionEventCallbacks(callbacks)
-                    .withClientId(clientId)
-                    .withEndpoint(endpoint)
-                    .withPort((short) port)
-                    .withCleanSession(true)
-                    .withProtocolOperationTimeoutMs(60000);
-
-            try (MqttClientConnection connection = builder.build()) {
-                // Connect and disconnect using the connection we created
-                // (see sampleConnectAndDisconnect for implementation)
-                cmdUtils.sampleConnectAndDisconnect(connection);
-
-                // Close the connection now that we are completely done with it.
-                connection.close();
+                .withClientId(cmdData.input_clientId)
+                .withEndpoint(cmdData.input_endpoint)
+                .withPort((short)cmdData.input_port)
+                .withCleanSession(true)
+                .withProtocolOperationTimeoutMs(60000);
+            MqttClientConnection connection = builder.build();
+            builder.close();
+
+            /**
+             * Verify the connection was created
+             */
+            if (connection == null)
+            {
+                onApplicationFailure(new RuntimeException("MQTT connection creation failed!"));
+            }
+
+            /**
+             * Connect and disconnect
+             */
+            CompletableFuture<Boolean> connected = connection.connect();
+            try {
+                boolean sessionPresent = connected.get();
+                System.out.println("Connected to " + (!sessionPresent ? "new" : "existing") + " session!");
+            } catch (Exception ex) {
+                throw new RuntimeException("Exception occurred during connect", ex);
             }
+            System.out.println("Disconnecting...");
+            CompletableFuture<Void> disconnected = connection.disconnect();
+            disconnected.get();
+            System.out.println("Disconnected.");
+
+            /**
+             * Close the connection now that it is complete
+             */
+            connection.close();
+
         } catch (CrtRuntimeException | InterruptedException | ExecutionException ex) {
             onApplicationFailure(ex);
         }
diff --git a/samples/X509CredentialsProviderConnect/src/main/java/x509credentialsproviderconnect/X509CredentialsProviderConnect.java b/samples/X509CredentialsProviderConnect/src/main/java/x509credentialsproviderconnect/X509CredentialsProviderConnect.java
index b42495a09..6654f7375 100644
--- a/samples/X509CredentialsProviderConnect/src/main/java/x509credentialsproviderconnect/X509CredentialsProviderConnect.java
+++ b/samples/X509CredentialsProviderConnect/src/main/java/x509credentialsproviderconnect/X509CredentialsProviderConnect.java
@@ -10,9 +10,14 @@
 import software.amazon.awssdk.crt.CrtRuntimeException;
 import software.amazon.awssdk.crt.mqtt.MqttClientConnection;
 import software.amazon.awssdk.crt.mqtt.MqttClientConnectionEvents;
-import software.amazon.awssdk.iot.iotjobs.model.RejectedError;
+import software.amazon.awssdk.crt.http.HttpProxyOptions;
+import software.amazon.awssdk.crt.io.TlsContextOptions;
+import software.amazon.awssdk.crt.io.ClientTlsContext;
+import software.amazon.awssdk.crt.auth.credentials.X509CredentialsProvider;
+import software.amazon.awssdk.iot.AwsIotMqttConnectionBuilder;
 
 import java.util.concurrent.ExecutionException;
+import java.util.concurrent.CompletableFuture;
 
 import utils.commandlineutils.CommandLineUtils;
 
@@ -39,15 +44,12 @@ static void onApplicationFailure(Throwable cause) {
 
     public static void main(String[] args) {
 
-        cmdUtils = new CommandLineUtils();
-        cmdUtils.registerProgramName("x509CredentialsProviderConnect");
-        cmdUtils.addCommonMQTTCommands();
-        cmdUtils.addCommonProxyCommands();
-        cmdUtils.addCommonX509Commands();
-        cmdUtils.registerCommand("signing_region", "<str>", "AWS IoT service region.");
-        cmdUtils.registerCommand("client_id", "<int>", "Client id to use (optional, default='test-*').");
-        cmdUtils.registerCommand("port", "<int>", "Port to connect to on the endpoint (optional, default='8883').");
-        cmdUtils.sendArguments(args);
+        /**
+         * cmdData is the arguments/input from the command line placed into a single struct for
+         * use in this sample. This handles all of the command line parsing, validating, etc.
+         * See the Utils/CommandLineUtils for more information.
+         */
+        CommandLineUtils.SampleCommandLineData cmdData = CommandLineUtils.getInputForIoTSample("x509CredentialsProviderConnect", args);
 
         MqttClientConnectionEvents callbacks = new MqttClientConnectionEvents() {
             @Override
@@ -64,20 +66,74 @@ public void onConnectionResumed(boolean sessionPresent) {
         };
 
         try {
-            // Create a connection using a certificate and key
-            // Note: The data for the connection is gotten from cmdUtils.
-            // (see buildWebsocketX509MQTTConnection for implementation)
-            MqttClientConnection connection = cmdUtils.buildWebsocketX509MQTTConnection(callbacks);
+
+            /**
+             * Build the MQTT connection using the builder
+             */
+            // ==============================
+            AwsIotMqttConnectionBuilder builder = AwsIotMqttConnectionBuilder.newMtlsBuilderFromPath(null, null);
+            if (cmdData.input_ca != "") {
+                builder.withCertificateAuthorityFromPath(null, cmdData.input_ca);
+            }
+            builder.withConnectionEventCallbacks(callbacks)
+                .withClientId(cmdData.input_clientId)
+                .withEndpoint(cmdData.input_endpoint)
+                .withPort((short)cmdData.input_port)
+                .withCleanSession(true)
+                .withProtocolOperationTimeoutMs(60000);
+            HttpProxyOptions proxyOptions = null;
+            if (cmdData.input_proxyHost != "" && cmdData.input_proxyPort > 0) {
+                proxyOptions = new HttpProxyOptions();
+                proxyOptions.setHost(cmdData.input_proxyHost);
+                proxyOptions.setPort(cmdData.input_proxyPort);
+                builder.withHttpProxyOptions(proxyOptions);
+            }
+            builder.withWebsockets(true);
+            builder.withWebsocketSigningRegion(cmdData.input_signingRegion);
+
+            TlsContextOptions x509TlsOptions = TlsContextOptions.createWithMtlsFromPath(cmdData.input_x509Cert, cmdData.input_x509Key);
+            if (cmdData.input_x509Ca != null) {
+                x509TlsOptions.withCertificateAuthorityFromPath(null, cmdData.input_x509Ca);
+            }
+
+            ClientTlsContext x509TlsContext = new ClientTlsContext(x509TlsOptions);
+            X509CredentialsProvider.X509CredentialsProviderBuilder x509builder = new X509CredentialsProvider.X509CredentialsProviderBuilder()
+                .withTlsContext(x509TlsContext)
+                .withEndpoint(cmdData.input_x509Endpoint)
+                .withRoleAlias(cmdData.input_x509Role)
+                .withThingName(cmdData.input_x509ThingName)
+                .withProxyOptions(proxyOptions);
+            X509CredentialsProvider provider = x509builder.build();
+            builder.withWebsocketCredentialsProvider(provider);
+
+            MqttClientConnection connection = builder.build();
+            builder.close();
+            provider.close();
+
             if (connection == null)
             {
                 onApplicationFailure(new RuntimeException("MQTT connection creation failed!"));
             }
-
-            // Connect and disconnect using the connection we created
-            // (see sampleConnectAndDisconnect for implementation)
-            cmdUtils.sampleConnectAndDisconnect(connection);
-
-            // Close the connection now that we are completely done with it.
+            // ==============================
+
+            /**
+             * Connect and disconnect
+             */
+            CompletableFuture<Boolean> connected = connection.connect();
+            try {
+                boolean sessionPresent = connected.get();
+                System.out.println("Connected to " + (!sessionPresent ? "new" : "existing") + " session!");
+            } catch (Exception ex) {
+                throw new RuntimeException("Exception occurred during connect", ex);
+            }
+            System.out.println("Disconnecting...");
+            CompletableFuture<Void> disconnected = connection.disconnect();
+            disconnected.get();
+            System.out.println("Disconnected.");
+
+            /**
+             * Close the connection now that it is complete
+             */
             connection.close();
 
         } catch (CrtRuntimeException | InterruptedException | ExecutionException ex) {