diff --git a/developer/test_release_software.md b/developer/test_release_software.md
index 1ab9647..4bc39e0 100644
--- a/developer/test_release_software.md
+++ b/developer/test_release_software.md
@@ -184,7 +184,7 @@
 It also depends on the following environmental variables being set, with
 these default values:
 
-- `DOCKER\_REGISTRY` - Docker Registry DNS address/IP with port and trailing
+- `DOCKER_REGISTRY` - Docker Registry DNS address/IP with port and trailing
   slash
 
   Default value is blank, example value: 10.0.0.1:5000/
@@ -213,6 +213,23 @@
 Currently the build process only creates amd64 images, but in the future
 multiarch images may be built as well.
 
+### Publish artifacts to a GitHub releases: `github-release_*`
+
+This builds and publishes binary artifacts to the GitHub releases page under a
+repository.
+
+To use this functionality, your Makefile must have a `make release` target that
+will build binary artifacts.
+
+In the configuration of this job, you must specify the name of the
+`github-organization` this repository is uploaded under, and specify a shell
+glob as `artifact-glob` to identify the files that were created.
+
+When a git tagged version is created, the Jenkins job will run `make release`
+then upload all the artifacts matching `artifact-glob` as well as generating
+and uploading a `checksum.SHA256` file containing hashes for the artifacts,
+which should be used to validate downloaded artifacts.
+
 ## Making new Jenkins jobs
 
 There may be tests written for a specific project. If you need another
diff --git a/profiles/seba/siab.md b/profiles/seba/siab.md
index 99e685b..826613c 100644
--- a/profiles/seba/siab.md
+++ b/profiles/seba/siab.md
@@ -187,7 +187,7 @@
 sudo mv /tmp/cordctl /usr/local/bin/cordctl
 sudo chmod a+x /usr/local/bin/cordctl
 mkdir -p ~/.cord
-printf "server: localhost:30011\nusername: admin@opencord.org\npassword: letmein\ngrpc:\n  timeout: 10s\n" > ~/.cord/config
+printf "server: 127.0.0.1:30011\nusername: admin@opencord.org\npassword: letmein\ngrpc:\n  timeout: 10s\n" > ~/.cord/config
 ```
 
 ### Other prerequisites
