diff --git a/.github/ISSUE_TEMPLATE/custom.md b/.github/ISSUE_TEMPLATE/custom.md
new file mode 100644
index 00000000..48d5f81f
--- /dev/null
+++ b/.github/ISSUE_TEMPLATE/custom.md
@@ -0,0 +1,10 @@
+---
+name: Custom issue template
+about: Describe this issue template's purpose here.
+title: ''
+labels: ''
+assignees: ''
+
+---
+
+
diff --git a/README.md b/README.md
index c2bf7c34..3be62202 100644
--- a/README.md
+++ b/README.md
@@ -1,81 +1,40 @@
-simpleworklist
-==============
+# simpleworklist
-Your Todo List for Getting Things Done
-
-Software-Stack: Spring-Boot, JPA, Spring MVC, Thymeleaf, Twitter Bootstrap, jQuery, HTML5
-
-Status
-------
-Getting Things Done
--------------------
+Your Todo List for Getting Things Done
+
+## Getting Things Done
GTD® and Getting Things Done® are registered trademarks of the David Allen Company.
SimpleWorklist is not affiliated with or endorsed by the David Allen Company.
-Developer Reminder
-------------------
-* Create serialVersionUID for Classes with "implements Serializable": use the JDK tool “serialver“
-
-
-Drag and Drop
--------------
-* https://jqueryhouse.com/jquery-drag-and-drop-plugins/
-* https://mdbootstrap.com/plugins/jquery/draggable/#introduction
-* https://github.com/Shopify/draggable/tree/master/examples/src/content/Droppable/UniqueDropzone
-* https://github.com/Shopify/draggable#documentation
-* https://jqueryhouse.com/jquery-drag-and-drop-plugins/
-* https://shopify.github.io/draggable/examples/simple-list.html
-* https://www.elated.com/drag-and-drop-with-jquery-your-essential-guide/
-* https://medium.com/@okandavut/using-jquery-ui-drag-drop-64a24e75e805
-
-Shortcuts
----------
-* https://fontawesome.com/icons?d=gallery&m=free
-* https://www.thymeleaf.org/doc/tutorials/3.0/usingthymeleaf.html
-* https://ckeditor.com/docs/ckeditor4/latest/guide/dev_installation.html
-* http://impossibl.github.io/pgjdbc-ng/docs/current/user-guide/#drivers
-* https://devcenter.heroku.com/articles/getting-started-with-java
-* https://devcenter.heroku.com/articles/java-support#specifying-a-java-version
-
-# java-getting-started
-
-A barebones Java app, which can easily be deployed to Heroku.
-
-This application supports the [Getting Started with Java on Heroku](https://devcenter.heroku.com/articles/getting-started-with-java) article - check it out.
+## Up and Running
+A Java Web App, which can easily be deployed to Heroku.
[](https://heroku.com/deploy)
-## Running Locally
-
-Make sure you have Java and Maven installed. Also, install the [Heroku CLI](https://cli.heroku.com/).
-
-```sh
-$ git clone https://github.com/heroku/java-getting-started.git
-$ cd java-getting-started
-$ mvn install
-$ heroku local:start
-```
-
-Your app should now be running on [localhost:5000](http://localhost:5000/).
-
-If you're going to use a database, ensure you have a local `.env` file that reads something like this:
-
-```
-JDBC_DATABASE_URL=jdbc:postgresql://localhost:5432/java_database_name
-```
+## URLs
+### Development
+* Heroku Deployment: [simpleworklist.herokuapp.com/](https://simpleworklist.herokuapp.com/)
+* For Developers: [localhost:5000](http://localhost:5000/)
+### Info
+* [spring-framework-java-apps.github.io/simpleworklist](http://spring-framework-java-apps.github.io/simpleworklist/)
-## Deploying to Heroku
+### Github Shortcuts
+* [Projects](https://github.com/Spring-Framework-Java-Apps/simpleworklist/projects)
+* [Milestones](https://github.com/Spring-Framework-Java-Apps/simpleworklist/milestones)
+* [Issues](https://github.com/Spring-Framework-Java-Apps/simpleworklist/issues)
+* [Releases](https://github.com/Spring-Framework-Java-Apps/simpleworklist/releases)
+* [Branches](https://github.com/Spring-Framework-Java-Apps/simpleworklist/branches)
+* [CI](https://github.com/Spring-Framework-Java-Apps/simpleworklist/actions)
-```sh
-$ heroku create
-$ git push heroku master
-$ heroku open
-```
+## Requirements
-## Documentation
+### Functional Requirements
+[Functional Requirements](etc/requirements/Requirements.md)
-For more information about using Java on Heroku, see these Dev Center articles:
+### Nonfunctional Requirements
+[Nonfunctional Requirements](etc/requirements/Nonfunctional_Requirements.md)
-- [Java on Heroku](https://devcenter.heroku.com/categories/java)
+## Development
+* [Changelog](etc/Changelog.md)
diff --git a/etc/CHANGELOG.md b/etc/CHANGELOG.md
new file mode 100644
index 00000000..4dc68c6f
--- /dev/null
+++ b/etc/CHANGELOG.md
@@ -0,0 +1,2 @@
+# Changelog
+
diff --git a/etc/development/Development.md b/etc/development/Development.md
new file mode 100644
index 00000000..faaad9f2
--- /dev/null
+++ b/etc/development/Development.md
@@ -0,0 +1,61 @@
+# Development
+
+## Developer Reminder
+* Create serialVersionUID for Classes with "implements Serializable": use the JDK tool “serialver“
+
+## Frontend
+
+### Drag and Drop
+* [jquery-drag-and-drop-plugins](https://jqueryhouse.com/jquery-drag-and-drop-plugins/)
+* [jquery draggable](https://mdbootstrap.com/plugins/jquery/draggable/#introduction)
+* [shopify draggable: UniqueDropzone](https://github.com/Shopify/draggable/tree/master/examples/src/content/Droppable/UniqueDropzone)
+* [shopify draggable: documentation](https://github.com/Shopify/draggable#documentation)
+* [shopify draggable: example](https://shopify.github.io/draggable/examples/simple-list.html)
+* [drag-and-drop-with-jquery-your-essential-guide](https://www.elated.com/drag-and-drop-with-jquery-your-essential-guide/)
+* [using-jquery-ui-drag-drop](https://medium.com/@okandavut/using-jquery-ui-drag-drop-64a24e75e805)
+
+### Shortcuts
+* [fontawesome](https://fontawesome.com/icons?d=gallery&m=free)
+* [ckeditor](https://ckeditor.com/docs/ckeditor4/latest/guide/dev_installation.html)
+
+### Templates
+* [thymeleaf](https://www.thymeleaf.org/doc/tutorials/3.0/usingthymeleaf.html)
+
+## Backend
+* [Alternative PostgreSQL JDBC 4.2* Driver](http://impossibl.github.io/pgjdbc-ng/docs/current/user-guide/#drivers)
+
+## Heroku
+### java
+* [heroku: getting-started-with-java](https://devcenter.heroku.com/articles/getting-started-with-java)
+* [heroku: java-support java-version](https://devcenter.heroku.com/articles/java-support#specifying-a-java-version)
+
+### Running Locally
+TBD:
+Make sure you have Java and Maven installed. Also, install the [Heroku CLI](https://cli.heroku.com/).
+
+```sh
+$ git clone https://github.com/heroku/java-getting-started.git
+$ cd java-getting-started
+$ mvn install
+$ heroku local:start
+```
+
+Your app should now be running on [localhost:5000](http://localhost:5000/).
+
+If you're going to use a database, ensure you have a local `.env` file that reads something like this:
+
+```
+JDBC_DATABASE_URL=jdbc:postgresql://localhost:5432/java_database_name
+```
+
+#### Deploying to Heroku
+
+```sh
+$ heroku create
+$ git push heroku master
+$ heroku open
+```
+
+#### Documentation
+For more information about using Java on Heroku, see these Dev Center articles:
+* [Java on Heroku](https://devcenter.heroku.com/categories/java)
diff --git a/etc/development/HOWTO.md b/etc/development/HOWTO.md
new file mode 100644
index 00000000..3c04d669
--- /dev/null
+++ b/etc/development/HOWTO.md
@@ -0,0 +1,67 @@
+ Howto Reminder
+
+## github
+* [Issues](https://github.com/BloodMoneyApp/bloodmoney/issues)
+* [Projects](https://github.com/BloodMoneyApp/bloodmoney/projects)
+* [Milestones](https://github.com/BloodMoneyApp/bloodmoney/milestones)
+* [Releases](https://github.com/BloodMoneyApp/bloodmoney/releases)
+
+## Development
+* [Changelog](etc/RELEASES.md)
+* [Todo](etc/TODO.md)
+* [Howto](etc/HOWTO.md)
+
+
+## 3rd Party Software
+### Howto
+* [Spring dependency-management-plugin](https://docs.spring.io/dependency-management-plugin/docs/current/reference/html/)
+* [Example on github: heroku and Gradle](https://github.com/heroku/gradle-getting-started/blob/master/build.gradle)
+* [Howto: Using lombok](https://projectlombok.org/setup/overview)
+* [Howto: Gradle Docker Compose](https://bmuschko.com/blog/gradle-docker-compose/)
+
+### Documentation
+* [spring-boot](https://spring.io/projects/spring-boot)
+* [spring-data-jpa](https://spring.io/projects/spring-data-jpa)
+* [spring-framework](https://spring.io/projects/spring-framework)
+* [spring-framework Data Access](https://docs.spring.io/spring-framework/docs/current/spring-framework-reference/data-access.html)
+* [spring-framework WebMVC](https://docs.spring.io/spring/docs/current/spring-framework-reference/web.html)
+* [spring-boot reference](https://docs.spring.io/spring-boot/docs/2.2.5.RELEASE/reference/html/)
+* [spring-boot appendix-application-properties](https://docs.spring.io/spring-boot/docs/2.2.5.RELEASE/reference/html/appendix-application-properties.html#common-application-properties)
+* [spring-boot api](https://docs.spring.io/spring-boot/docs/2.2.5.RELEASE/api/)
+* [spring-data-jpa](https://docs.spring.io/spring-data/jpa/docs/2.2.5.RELEASE/reference/html/#reference)
+
+### Gradle Plugins
+* [org.springframework.boot](https://plugins.gradle.org/plugin/org.springframework.boot)
+* [org.springframework.cloud.contract](https://plugins.gradle.org/plugin/org.springframework.cloud.contract)
+* [io.spring.dependency-management](https://plugins.gradle.org/plugin/io.spring.dependency-management)
+* [org.asciidoctor.jvm.convert](https://plugins.gradle.org/plugin/org.asciidoctor.jvm.convert)
+* [com.avast.gradle.docker-compose](https://plugins.gradle.org/plugin/com.avast.gradle.docker-compose)
+* [org.liquibase.gradle](https://plugins.gradle.org/plugin/org.liquibase.gradle)
+
+### Github Repos
+* [spring-cloud-contract](https://github.com/spring-cloud/spring-cloud-contract)
+* [dependency-management-plugin](https://github.com/spring-gradle-plugins/dependency-management-plugin)
+* [asciidoctor-gradle-plugin](https://github.com/asciidoctor/asciidoctor-gradle-plugin)
+* [gradle-docker-compose-plugin](https://github.com/avast/gradle-docker-compose-plugin)
+* [liquibase-gradle-plugin](https://github.com/liquibase/liquibase-gradle-plugin)
+
+## Database and JPA
+### DB Datatypes
+* [H2 Datatypes](http://www.h2database.com/html/datatypes.html)
+* [PostgreSQL Datatypes](https://www.postgresql.org/docs/11/datatype.html)
+* LocalDateTime and TimeZone: TODO
+
+### UUID and Optimistic Locking
+* UUID: TODO
+
+### Database Schema Evolution with Spring Boot JPA
+* TODO
+* org.flywaydb:flyway
+* org.liquibase:liquibase https://www.liquibase.org/documentation/maven/index.html
+
+
+## Frontend with webjars
+
+### updating webjar Versions:
+* change Version in build.gradle "ext" (Line 40)
+* change Version in src/main/resources/templates/layout/page.html Section head.tw-head and div.tw-footer (Lines 16, 98)
diff --git a/etc/application_properties/application.properties_sample.txt b/etc/development/application.properties_sample.txt
similarity index 97%
rename from etc/application_properties/application.properties_sample.txt
rename to etc/development/application.properties_sample.txt
index 86e4f29b..df079878 100644
--- a/etc/application_properties/application.properties_sample.txt
+++ b/etc/development/application.properties_sample.txt
@@ -1,29 +1,29 @@
-spring.session.store-type=jdbc
-spring.datasource.url=jdbc:postgresql://localhost:5432/simpleworklist
-spring.datasource.username=simpleworklist
-spring.datasource.password=simpleworklistpwd
-spring.datasource.driver-class-name=org.postgresql.Driver
-spring.jpa.hibernate.ddl-auto=create-drop
-#spring.jpa.hibernate.ddl-auto=update
-spring.jpa.show-sql=true
-spring.jpa.hibernate.dialect=org.hibernate.dialect.PostgreSQL95Dialect
-spring.jpa.properties.hibernate.temp.use_jdbc_metadata_defaults=false
-spring.thymeleaf.cache=false
-
-org.woehlke.simpleworklist.user.strengthBCryptPasswordEncoder=10
-
-org.woehlke.simpleworklist.mail.host=********
-org.woehlke.simpleworklist.mail.port=465
-org.woehlke.simpleworklist.mail.username=********
-org.woehlke.simpleworklist.mail.password=********
-org.woehlke.simpleworklist.mail.smtp.auth=true
-org.woehlke.simpleworklist.mail.smtp.sslEnable=true
-org.woehlke.simpleworklist.mail.smtp.socketFactoryPort=465
-org.woehlke.simpleworklist.mail.smtp.socketFactoryClass=javax.net.ssl.SSLSocketFactory
-
-org.woehlke.simpleworklist.mvc.controllerPageSize=10
-
-org.woehlke.simpleworklist.registration.maxRetries=5
-org.woehlke.simpleworklist.registration.ttlEmailVerificationRequest=86400000
-org.woehlke.simpleworklist.registration.urlHost=localhost:8080
-org.woehlke.simpleworklist.registration.mailFrom=********
+spring.session.store-type=jdbc
+spring.datasource.url=jdbc:postgresql://localhost:5432/simpleworklist
+spring.datasource.username=simpleworklist
+spring.datasource.password=simpleworklistpwd
+spring.datasource.driver-class-name=org.postgresql.Driver
+spring.jpa.hibernate.ddl-auto=create-drop
+#spring.jpa.hibernate.ddl-auto=update
+spring.jpa.show-sql=true
+spring.jpa.hibernate.dialect=org.hibernate.dialect.PostgreSQL95Dialect
+spring.jpa.properties.hibernate.temp.use_jdbc_metadata_defaults=false
+spring.thymeleaf.cache=false
+
+org.woehlke.simpleworklist.user.strengthBCryptPasswordEncoder=10
+
+org.woehlke.simpleworklist.mail.host=********
+org.woehlke.simpleworklist.mail.port=465
+org.woehlke.simpleworklist.mail.username=********
+org.woehlke.simpleworklist.mail.password=********
+org.woehlke.simpleworklist.mail.smtp.auth=true
+org.woehlke.simpleworklist.mail.smtp.sslEnable=true
+org.woehlke.simpleworklist.mail.smtp.socketFactoryPort=465
+org.woehlke.simpleworklist.mail.smtp.socketFactoryClass=javax.net.ssl.SSLSocketFactory
+
+org.woehlke.simpleworklist.mvc.controllerPageSize=10
+
+org.woehlke.simpleworklist.registration.maxRetries=5
+org.woehlke.simpleworklist.registration.ttlEmailVerificationRequest=86400000
+org.woehlke.simpleworklist.registration.urlHost=localhost:8080
+org.woehlke.simpleworklist.registration.mailFrom=********
diff --git a/etc/application_properties/application.properties_test_sample.txt b/etc/development/application.properties_test_sample.txt
similarity index 97%
rename from etc/application_properties/application.properties_test_sample.txt
rename to etc/development/application.properties_test_sample.txt
index bd4259aa..c4a013eb 100644
--- a/etc/application_properties/application.properties_test_sample.txt
+++ b/etc/development/application.properties_test_sample.txt
@@ -1,29 +1,29 @@
-spring.session.store-type=jdbc
-spring.datasource.url=jdbc:postgresql://localhost:5432/simpleworklisttest
-spring.datasource.username=simpleworklist
-spring.datasource.password=simpleworklistpwd
-spring.datasource.driver-class-name=org.postgresql.Driver
-spring.jpa.hibernate.ddl-auto=create-drop
-#spring.jpa.hibernate.ddl-auto=update
-spring.jpa.show-sql=true
-spring.jpa.hibernate.dialect=org.hibernate.dialect.PostgreSQL95Dialect
-spring.jpa.properties.hibernate.temp.use_jdbc_metadata_defaults=false
-spring.thymeleaf.cache=false
-
-org.woehlke.simpleworklist.user.strengthBCryptPasswordEncoder=10
-
-org.woehlke.simpleworklist.mail.host=********
-org.woehlke.simpleworklist.mail.port=465
-org.woehlke.simpleworklist.mail.username=********
-org.woehlke.simpleworklist.mail.password=********
-org.woehlke.simpleworklist.mail.smtp.auth=true
-org.woehlke.simpleworklist.mail.smtp.sslEnable=true
-org.woehlke.simpleworklist.mail.smtp.socketFactoryPort=465
-org.woehlke.simpleworklist.mail.smtp.socketFactoryClass=javax.net.ssl.SSLSocketFactory
-
-org.woehlke.simpleworklist.mvc.controllerPageSize=10
-
-org.woehlke.simpleworklist.registration.maxRetries=5
-org.woehlke.simpleworklist.registration.ttlEmailVerificationRequest=86400000
-org.woehlke.simpleworklist.registration.urlHost=localhost:8080
-org.woehlke.simpleworklist.registration.mailFrom=********
+spring.session.store-type=jdbc
+spring.datasource.url=jdbc:postgresql://localhost:5432/simpleworklisttest
+spring.datasource.username=simpleworklist
+spring.datasource.password=simpleworklistpwd
+spring.datasource.driver-class-name=org.postgresql.Driver
+spring.jpa.hibernate.ddl-auto=create-drop
+#spring.jpa.hibernate.ddl-auto=update
+spring.jpa.show-sql=true
+spring.jpa.hibernate.dialect=org.hibernate.dialect.PostgreSQL95Dialect
+spring.jpa.properties.hibernate.temp.use_jdbc_metadata_defaults=false
+spring.thymeleaf.cache=false
+
+org.woehlke.simpleworklist.user.strengthBCryptPasswordEncoder=10
+
+org.woehlke.simpleworklist.mail.host=********
+org.woehlke.simpleworklist.mail.port=465
+org.woehlke.simpleworklist.mail.username=********
+org.woehlke.simpleworklist.mail.password=********
+org.woehlke.simpleworklist.mail.smtp.auth=true
+org.woehlke.simpleworklist.mail.smtp.sslEnable=true
+org.woehlke.simpleworklist.mail.smtp.socketFactoryPort=465
+org.woehlke.simpleworklist.mail.smtp.socketFactoryClass=javax.net.ssl.SSLSocketFactory
+
+org.woehlke.simpleworklist.mvc.controllerPageSize=10
+
+org.woehlke.simpleworklist.registration.maxRetries=5
+org.woehlke.simpleworklist.registration.ttlEmailVerificationRequest=86400000
+org.woehlke.simpleworklist.registration.urlHost=localhost:8080
+org.woehlke.simpleworklist.registration.mailFrom=********
diff --git a/etc/docs/deploying-spring-boot-apps.md b/etc/development/archiv/deploying-spring-boot-apps.md
similarity index 97%
rename from etc/docs/deploying-spring-boot-apps.md
rename to etc/development/archiv/deploying-spring-boot-apps.md
index b1f20e74..91a0d368 100644
--- a/etc/docs/deploying-spring-boot-apps.md
+++ b/etc/development/archiv/deploying-spring-boot-apps.md
@@ -1,254 +1,254 @@
-```
-:::-- rundoc
-email = ENV['HEROKU_EMAIL'] || `heroku auth:whoami`
-
-Rundoc.configure do |config|
- config.project_root = "deploying-spring-boot-apps"
- config.filter_sensitive(email => "developer@example.com")
-end
-```
-
-
-The Spring Boot model of deploying standalone applications is a great
-fit for Heroku. You can use either Maven or Gradle to deploy a Spring application on Heroku, but for this guide we'll assume that you're using Maven and have [Maven 3](http://maven.apache.org/download.html) installed on your machine.
-
-To begin, create a [free Heroku account](https://signup.heroku.com/).
-Then download and install the Heroku CLI.
-
-Download the Heroku CLI
-
-Once installed, you can use the `heroku` command from the terminal to log in using the email address and password you used when creating your Heroku account:
-
-```term
-$ heroku login
-heroku: Press any key to open up the browser to login or q to exit
- › Warning: If browser does not open, visit
- › https://cli-auth.heroku.com/auth/browser/***
-heroku: Waiting for login...
-Logging in... done
-Logged in as me@example.com
-```
-
-To check that your key was added, run `heroku keys`. If your key isn’t there, you
-can add it manually by running `heroku keys:add`. For more information about SSH
-keys, see [Managing Your SSH Keys](https://devcenter.heroku.com/articles/keys).
-
-## Creating a Spring Boot app
-
-To create a new Spring Boot application, first install the Spring Boot CLI as described in the [Spring Boot documentation](https://docs.spring.io/spring-boot/docs/current/reference/html/cli-using-the-cli.html). This will add a `spring` command to your path.
-
->note
->You can also start with a working [sample app](https://github.com/heroku/java-getting-started) if you'd prefer.
-
-Use the CLI to create a new application by running this command:
-
-```term
-:::>- $ spring init --dependencies=web demo
-```
-
-Then move into the application directory:
-
-```term
-:::>- $ cd demo
-```
-
-The application does not have any custom logic by default -- it's just an empty template. To add some behavior, open the `src/main/java/com/example/demo/DemoApplication.java` file and put the following code in it:
-
-```java
-:::>> file.write src/main/java/com/example/demo/DemoApplication.java
-package com.example.demo;
-
-import org.springframework.boot.SpringApplication;
-import org.springframework.boot.autoconfigure.SpringBootApplication;
-import org.springframework.web.bind.annotation.*;
-import org.springframework.stereotype.*;
-
-@Controller
-@SpringBootApplication
-public class DemoApplication {
-
- @RequestMapping("/")
- @ResponseBody
- String home() {
- return "Hello World!";
- }
-
- public static void main(String[] args) {
- SpringApplication.run(DemoApplication.class, args);
- }
-}
-```
-
-This creates a simple request mapping that displayed "Hello World!" in the browser. You could run the application locally to confirm this, but we'll jump straight to running it on Heroku.
-
-## Preparing a Spring Boot app for Heroku
-
-Before you can deploy the app to Heroku, you'll need to create a Git repository for the application and add all of the code to it by running these commands:
-
-```term
-:::>- $ git init
-:::>- $ git add .
-:::>- $ git commit -m "first commit"
-```
-
-You'll deploy the app by pushing this Git repo to Heroku. It's also possible to deploy using the [Heroku Maven plugin](deploying-java-applications-with-the-heroku-maven-plugin), but this guide will focus on using Git and the Heroku CLI.
-
-In order to deploy to Heroku, you'll first need to provision a new Heroku app. Run this command:
-
-```term
-:::>> $ heroku create
-```
-
-This also creates a remote repository called `heroku` in
-your local git repo. Heroku generates a random name (in this case `nameless-lake-8055`)
-for your app. You can rename it later with the `heroku apps:rename` command.
-
-Now deploy your code:
-
-```term
-:::>- $ git push heroku master
-:::-> | $ (head -6; echo "..."; tail -18)
-```
-
-Heroku automatically detects the application as a Maven/Java app due to the presence of a `pom.xml` file. It installed Java 8 by default, but you can easily configure this with a `system.properties` file as described in the [Specifying a Java version](https://devcenter.heroku.com/articles/java-support#specifying-a-java-version) Dev Center article. It will run your app using the [default command](https://devcenter.heroku.com/articles/java-support#default-web-process-type).
-
-All that said, the application is now deployed. You can visit the app's URL by running this command:
-
-```term
-:::>- $ heroku open
-```
-
-You'll see the "Hello World!" text in the browser.
-
-You can view the logs for the application by running this command:
-
-```term
-:::>- background.start("heroku logs --tail", name: "tail", wait: "State changed from starting to up", timeout: 45)
-:::-> | tail -10
-:::-- background.stop(name: "tail")
-```
-
-Reload your application in the browser, and you’ll see another log message generated for that request. Press `Control+C` to stop streaming the logs.
-
-To learn more about the basics of deploying a Maven-based Java application on Heroku, try following the [Getting Started with Java on Heroku](getting-started-with-java) guide. This guide covers many steps that are not specific to Spring Boot.
-
-The remainder of this article provides a cursory overview of some of the most common settings you'll need to adjust.
-
-## Connecting to a database
-
-You can attach a PostgreSQL database to your app by running the following command from the CLI:
-
-```term
-:::>- $ heroku addons:create heroku-postgresql
-```
-
-If you prefer to use MySQL or another database vendor, check out [Add-ons Marketplace](https://elements.heroku.com/addons) to see what is available.
-
-Now you can list the configuration variables for your app to display the URL needed to connect to the database, DATABASE_URL:
-
-```term
-:::>> $ heroku config
-```
-
-Heroku also provides a `pg` command that shows a lot more:
-
-```term
-:::>> $ heroku pg
-```
-
-This indicates a hobby database (free) is running Postgres 9.3.3, with a single row of data.
-
-Once the database add-on has been created, Heroku will automatically populate the environment variables `SPRING_DATASOURCE_URL`, `SPRING_DATASOURCE_USERNAME`, and `SPRING_DATASOURCE_PASSWORD`. These environment variables should allow your Spring Boot application to connect to the database without any other configuration as long as you add a PostgreSQL JDBC driver to your dependencies like so:
-
-```xml
-:::>> file.append("pom.xml#26")
-
- org.springframework.boot
- spring-boot-starter-jdbc
-
-
- org.postgresql
- postgresql
-
-```
-
-You can customize your application's database configuration in your `application.properties`. For example:
-
-
-```properties
-:::>> file.write src/main/resources/application.properties
-spring.datasource.driverClassName=org.postgresql.Driver
-spring.datasource.maxActive=10
-spring.datasource.maxIdle=5
-spring.datasource.minIdle=2
-spring.datasource.initialSize=5
-spring.datasource.removeAbandoned=true
-```
-
-Then you can then add a configuration bean to your app.
-
-```java
-:::>> file.write src/main/java/demo/DatabaseConfig.java
-package com.example.demo;
-
-import com.zaxxer.hikari.*;
-import org.springframework.beans.factory.annotation.Value;
-import org.springframework.context.annotation.*;
-import javax.sql.DataSource;
-
-@Configuration
-public class DatabaseConfig {
-
- @Value("${spring.datasource.url}")
- private String dbUrl;
-
- @Bean
- public DataSource dataSource() {
- HikariConfig config = new HikariConfig();
- config.setJdbcUrl(dbUrl);
- return new HikariDataSource(config);
- }
-}
-```
-
-```
-:::-- $ git add .
-:::-- $ git commit -m "database"
-:::-- $ git push heroku master
-:::-- $ cd ..
-:::-- $ mv demo deploying-spring-boot-apps
-```
-
-For more information, see [Connecting to Relational Databases on Heroku with Java](articles/connecting-to-relational-databases-on-heroku-with-java).
-
-Now your application should be able to connect to the database. You can follow our guide on [Running Database Migrations for Java Apps](https://devcenter.heroku.com/articles/running-database-migrations-for-java-apps) to initialize the database. The [sample app](https://github.com/kissaten/spring-boot-heroku-demo) uses Liquibase.
-
-## Customizing the boot command
-
-You can override the default command used to run your app or define custom process types using a [`Procfile`](https://devcenter.heroku.com/articles/procfile). The correct command depends on what you need to do with your app. Common process types are used to [run a web process](https://devcenter.heroku.com/articles/java-support#default-web-process-type) or [run database migrations](https://devcenter.heroku.com/articles/running-database-migrations-for-java-apps).
-
-## Next steps
-
-For more complete examples of Spring Boot apps that run on Heroku see:
-
-* [Getting Started on Heroku with Java](articles/getting-started-with-java#introduction)
-* [Spring Petclinic Demo for Heroku](https://github.com/kissaten/spring-petclinic)
-
-Heroku provides a wide range of features for Spring applications. You can provision
-add-ons that introduce third-party cloud services like persistence, logging, monitoring and more.
-The [add-on marketplace](https://elements.heroku.com/addons/#data-stores) has a large
-number of data stores, from Redis and MongoDB providers, to Postgres and MySQL.
-
-You can read more about [How Heroku Works](https://devcenter.heroku.com/articles/how-heroku-works)
-to get a technical overview of the concepts you’ll encounter while writing, configuring, deploying and running applications.
-Then visit the [Java category on Dev Center](https://devcenter.heroku.com/categories/java-support)
-to learn more about developing and deploying Spring applications.
-If you experience any trouble with your application as you migrate to Heroku, reach out to any of our [Support channels](https://devcenter.heroku.com/articles/support-channels).
-
-For more information on deploying Spring apps, see the [Spring documentation](http://projects.spring.io/spring-boot/#quick-start) and the [Spring Boot documentation on deploy to Heroku](http://docs.spring.io/spring-boot/docs/current/reference/html/cloud-deployment.html#cloud-deployment-heroku).
+```
+:::-- rundoc
+email = ENV['HEROKU_EMAIL'] || `heroku auth:whoami`
+
+Rundoc.configure do |config|
+ config.project_root = "deploying-spring-boot-apps"
+ config.filter_sensitive(email => "developer@example.com")
+end
+```
+
+
+The Spring Boot model of deploying standalone applications is a great
+fit for Heroku. You can use either Maven or Gradle to deploy a Spring application on Heroku, but for this guide we'll assume that you're using Maven and have [Maven 3](http://maven.apache.org/download.html) installed on your machine.
+
+To begin, create a [free Heroku account](https://signup.heroku.com/).
+Then download and install the Heroku CLI.
+
+Download the Heroku CLI
+
+Once installed, you can use the `heroku` command from the terminal to log in using the email address and password you used when creating your Heroku account:
+
+```term
+$ heroku login
+heroku: Press any key to open up the browser to login or q to exit
+ › Warning: If browser does not open, visit
+ › https://cli-auth.heroku.com/auth/browser/***
+heroku: Waiting for login...
+Logging in... done
+Logged in as me@example.com
+```
+
+To check that your key was added, run `heroku keys`. If your key isn’t there, you
+can add it manually by running `heroku keys:add`. For more information about SSH
+keys, see [Managing Your SSH Keys](https://devcenter.heroku.com/articles/keys).
+
+## Creating a Spring Boot app
+
+To create a new Spring Boot application, first install the Spring Boot CLI as described in the [Spring Boot documentation](https://docs.spring.io/spring-boot/docs/current/reference/html/cli-using-the-cli.html). This will add a `spring` command to your path.
+
+>note
+>You can also start with a working [sample app](https://github.com/heroku/java-getting-started) if you'd prefer.
+
+Use the CLI to create a new application by running this command:
+
+```term
+:::>- $ spring init --dependencies=web demo
+```
+
+Then move into the application directory:
+
+```term
+:::>- $ cd demo
+```
+
+The application does not have any custom logic by default -- it's just an empty template. To add some behavior, open the `src/main/java/com/example/demo/DemoApplication.java` file and put the following code in it:
+
+```java
+:::>> file.write src/main/java/com/example/demo/DemoApplication.java
+package com.example.demo;
+
+import org.springframework.boot.SpringApplication;
+import org.springframework.boot.autoconfigure.SpringBootApplication;
+import org.springframework.web.bind.annotation.*;
+import org.springframework.stereotype.*;
+
+@Controller
+@SpringBootApplication
+public class DemoApplication {
+
+ @RequestMapping("/")
+ @ResponseBody
+ String home() {
+ return "Hello World!";
+ }
+
+ public static void main(String[] args) {
+ SpringApplication.run(DemoApplication.class, args);
+ }
+}
+```
+
+This creates a simple request mapping that displayed "Hello World!" in the browser. You could run the application locally to confirm this, but we'll jump straight to running it on Heroku.
+
+## Preparing a Spring Boot app for Heroku
+
+Before you can deploy the app to Heroku, you'll need to create a Git repository for the application and add all of the code to it by running these commands:
+
+```term
+:::>- $ git init
+:::>- $ git add .
+:::>- $ git commit -m "first commit"
+```
+
+You'll deploy the app by pushing this Git repo to Heroku. It's also possible to deploy using the [Heroku Maven plugin](deploying-java-applications-with-the-heroku-maven-plugin), but this guide will focus on using Git and the Heroku CLI.
+
+In order to deploy to Heroku, you'll first need to provision a new Heroku app. Run this command:
+
+```term
+:::>> $ heroku create
+```
+
+This also creates a remote repository called `heroku` in
+your local git repo. Heroku generates a random name (in this case `nameless-lake-8055`)
+for your app. You can rename it later with the `heroku apps:rename` command.
+
+Now deploy your code:
+
+```term
+:::>- $ git push heroku master
+:::-> | $ (head -6; echo "..."; tail -18)
+```
+
+Heroku automatically detects the application as a Maven/Java app due to the presence of a `pom.xml` file. It installed Java 8 by default, but you can easily configure this with a `system.properties` file as described in the [Specifying a Java version](https://devcenter.heroku.com/articles/java-support#specifying-a-java-version) Dev Center article. It will run your app using the [default command](https://devcenter.heroku.com/articles/java-support#default-web-process-type).
+
+All that said, the application is now deployed. You can visit the app's URL by running this command:
+
+```term
+:::>- $ heroku open
+```
+
+You'll see the "Hello World!" text in the browser.
+
+You can view the logs for the application by running this command:
+
+```term
+:::>- background.start("heroku logs --tail", name: "tail", wait: "State changed from starting to up", timeout: 45)
+:::-> | tail -10
+:::-- background.stop(name: "tail")
+```
+
+Reload your application in the browser, and you’ll see another log message generated for that request. Press `Control+C` to stop streaming the logs.
+
+To learn more about the basics of deploying a Maven-based Java application on Heroku, try following the [Getting Started with Java on Heroku](getting-started-with-java) guide. This guide covers many steps that are not specific to Spring Boot.
+
+The remainder of this article provides a cursory overview of some of the most common settings you'll need to adjust.
+
+## Connecting to a database
+
+You can attach a PostgreSQL database to your app by running the following command from the CLI:
+
+```term
+:::>- $ heroku addons:create heroku-postgresql
+```
+
+If you prefer to use MySQL or another database vendor, check out [Add-ons Marketplace](https://elements.heroku.com/addons) to see what is available.
+
+Now you can list the configuration variables for your app to display the URL needed to connect to the database, DATABASE_URL:
+
+```term
+:::>> $ heroku config
+```
+
+Heroku also provides a `pg` command that shows a lot more:
+
+```term
+:::>> $ heroku pg
+```
+
+This indicates a hobby database (free) is running Postgres 9.3.3, with a single row of data.
+
+Once the database add-on has been created, Heroku will automatically populate the environment variables `SPRING_DATASOURCE_URL`, `SPRING_DATASOURCE_USERNAME`, and `SPRING_DATASOURCE_PASSWORD`. These environment variables should allow your Spring Boot application to connect to the database without any other configuration as long as you add a PostgreSQL JDBC driver to your dependencies like so:
+
+```xml
+:::>> file.append("pom.xml#26")
+
+ org.springframework.boot
+ spring-boot-starter-jdbc
+
+
+ org.postgresql
+ postgresql
+
+```
+
+You can customize your application's database configuration in your `application.properties`. For example:
+
+
+```properties
+:::>> file.write src/main/resources/application.properties
+spring.datasource.driverClassName=org.postgresql.Driver
+spring.datasource.maxActive=10
+spring.datasource.maxIdle=5
+spring.datasource.minIdle=2
+spring.datasource.initialSize=5
+spring.datasource.removeAbandoned=true
+```
+
+Then you can then add a configuration bean to your app.
+
+```java
+:::>> file.write src/main/java/demo/DatabaseConfig.java
+package com.example.demo;
+
+import com.zaxxer.hikari.*;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.context.annotation.*;
+import javax.sql.DataSource;
+
+@Configuration
+public class DatabaseConfig {
+
+ @Value("${spring.datasource.url}")
+ private String dbUrl;
+
+ @Bean
+ public DataSource dataSource() {
+ HikariConfig config = new HikariConfig();
+ config.setJdbcUrl(dbUrl);
+ return new HikariDataSource(config);
+ }
+}
+```
+
+```
+:::-- $ git add .
+:::-- $ git commit -m "database"
+:::-- $ git push heroku master
+:::-- $ cd ..
+:::-- $ mv demo deploying-spring-boot-apps
+```
+
+For more information, see [Connecting to Relational Databases on Heroku with Java](articles/connecting-to-relational-databases-on-heroku-with-java).
+
+Now your application should be able to connect to the database. You can follow our guide on [Running Database Migrations for Java Apps](https://devcenter.heroku.com/articles/running-database-migrations-for-java-apps) to initialize the database. The [sample app](https://github.com/kissaten/spring-boot-heroku-demo) uses Liquibase.
+
+## Customizing the boot command
+
+You can override the default command used to run your app or define custom process types using a [`Procfile`](https://devcenter.heroku.com/articles/procfile). The correct command depends on what you need to do with your app. Common process types are used to [run a web process](https://devcenter.heroku.com/articles/java-support#default-web-process-type) or [run database migrations](https://devcenter.heroku.com/articles/running-database-migrations-for-java-apps).
+
+## Next steps
+
+For more complete examples of Spring Boot apps that run on Heroku see:
+
+* [Getting Started on Heroku with Java](articles/getting-started-with-java#introduction)
+* [Spring Petclinic Demo for Heroku](https://github.com/kissaten/spring-petclinic)
+
+Heroku provides a wide range of features for Spring applications. You can provision
+add-ons that introduce third-party cloud services like persistence, logging, monitoring and more.
+The [add-on marketplace](https://elements.heroku.com/addons/#data-stores) has a large
+number of data stores, from Redis and MongoDB providers, to Postgres and MySQL.
+
+You can read more about [How Heroku Works](https://devcenter.heroku.com/articles/how-heroku-works)
+to get a technical overview of the concepts you’ll encounter while writing, configuring, deploying and running applications.
+Then visit the [Java category on Dev Center](https://devcenter.heroku.com/categories/java-support)
+to learn more about developing and deploying Spring applications.
+If you experience any trouble with your application as you migrate to Heroku, reach out to any of our [Support channels](https://devcenter.heroku.com/articles/support-channels).
+
+For more information on deploying Spring apps, see the [Spring documentation](http://projects.spring.io/spring-boot/#quick-start) and the [Spring Boot documentation on deploy to Heroku](http://docs.spring.io/spring-boot/docs/current/reference/html/cloud-deployment.html#cloud-deployment-heroku).
diff --git a/etc/docs/java-getting-started.md b/etc/development/archiv/java-getting-started.md
similarity index 97%
rename from etc/docs/java-getting-started.md
rename to etc/development/archiv/java-getting-started.md
index 0577695c..c63ccdd0 100644
--- a/etc/docs/java-getting-started.md
+++ b/etc/development/archiv/java-getting-started.md
@@ -1,554 +1,554 @@
-```
-:::-- rundoc
-email = ENV['HEROKU_EMAIL'] || `heroku auth:whoami`
-
-Rundoc.configure do |config|
- config.project_root = "java-getting-started"
- config.filter_sensitive(email => "developer@example.com")
-end
-```
-
-
-Introduction
-
-This tutorial will have you deploying a Java app in minutes.
-
-Hang on for a few more minutes to learn how it all works, so you can make the most out of Heroku.
-
-The tutorial assumes that you already have:
-
-* A free Heroku account
-* Java 8 installed
-* Maven 3 installed
-
-If you'd prefer to use Gradle instead of Maven, please see the [Getting Started with Gradle on Heroku](getting-started-with-gradle-on-heroku) guide.
-
-Set up
-
->callout
->The Heroku CLI requires **Git**, the popular version control system. If you don't already have Git installed, complete the following before proceeding:
->
-> * Git installation
-> * First-time Git setup
-
-In this step you'll install the Heroku Command Line Interface (CLI). You use the CLI to manage and scale your applications, provision add-ons, view your application logs, and run your application locally.
-
-Download and run the installer for your platform:
-
-
-
-When installation completes, you can use the `heroku` command from your terminal.
-
-On Windows, start the Command Prompt (cmd.exe) or Powershell to access the command shell.
-
-Use the `heroku login` command to log in to the Heroku CLI:
-
-```term
-$ heroku login
-heroku: Press any key to open up the browser to login or q to exit
- › Warning: If browser does not open, visit
- › https://cli-auth.heroku.com/auth/browser/***
-heroku: Waiting for login...
-Logging in... done
-Logged in as me@example.com
-```
-
-This command opens your web browser to the Heroku login page. If your browser is already logged in to Heroku, simply click the **Log in** button displayed on the page.
-
-This authentication is required for both the `heroku` and `git` commands to work correctly.
-
-Note that if you’re behind a firewall that requires use of a proxy to connect with external HTTP/HTTPS services, [you can set the `HTTP_PROXY` or `HTTPS_PROXY` environment variables](articles/using-the-cli#using-an-http-proxy) in your local development environment before running the `heroku` command.
-
-Prepare the app
-
-In this step, you will prepare a sample application that's ready to be deployed to Heroku.
-
->callout
->If you are new to Heroku, it is recommended that you
->complete this tutorial using the Heroku-provided sample application.
->
->However, if you have your own existing application that you want to deploy
->instead, see this article
->to learn how to prepare it for Heroku deployment.
-
-To create a local copy of a sample app that you can deploy to Heroku, execute the following commands in your local command shell or terminal:
-
-
-```term
-:::>- $ git clone https://github.com/heroku/java-getting-started
-:::>- $ cd java-getting-started
-:::-- $ git fetch
-:::-- $ git merge origin/master
-```
-
-You now have a functioning Git repository that contains a simple Java application. The application includes a `pom.xml` file, which is used by Java's dependency manager, Maven.
-
-Deploy the app
-
-In this step you'll deploy the sample app to Heroku.
-
-First, create an app on Heroku, which prepares Heroku to receive your source code:
-
-```term
-:::>> $ heroku create
-```
-
-When you create an app, a Git remote (named `heroku`) is also created and associated with your local Git repository.
-
-By default, Heroku generates a random name (in this case `warm-eyrie-9006`) for your app. You can pass a parameter to specify your own app name.
-
-Now deploy your code:
-
-```term
-:::>- $ git push heroku master
-:::-> | $ (head -6; echo "..."; tail -18)
-```
-
-The application is now deployed. Ensure that at least one instance of the app is running:
-
-```term
-:::>- $ heroku ps:scale web=1
-```
-
-Now visit the app at the URL generated by its app name. As a handy shortcut, you can open the website like so:
-
-```term
-:::>- $ heroku open
-```
-
-View logs
-
-Heroku aggregates all of the output streams from both your app and the platform's components into a single channel of time-ordered logs.
-
-View information about your running app using the `heroku logs --tail` command:
-
-```term
-:::>- background.start("heroku logs --tail", name: "tail", wait: "State changed from starting to up", timeout: 45)
-:::-> | tail -10
-:::-- background.stop(name: "tail")
-```
-
-Visit your application in the browser again to generate another log message.
-
-Press `CTRL+C` to stop streaming logs.
-
-Define a Procfile
-
-Heroku apps use a special plaintext file called the [Procfile](procfile) to explicitly declare what command should be executed to start your app.
-
-The `Procfile` in the example app you deployed looks like this:
-
-```yaml
-:::-> $ cat Procfile
-```
-
-This declares a single process type, `web`, and the command needed to run it. The name `web` is important here. It declares that this process type will be attached to Heroku's [HTTP routing](http-routing) stack, and it will be able to receive web traffic.
-
-Procfiles can contain additional process types. For example, you might declare one for a background worker that processes items off of a queue.
-
-Scale the app
-
-Right now, your app is running on a single web [dyno](dynos). A dyno is a lightweight Linux container that runs the command specified in your `Procfile`.
-
-You can check how many dynos are running using the `heroku ps` command:
-
-```term
-:::>> $ heroku ps
-```
-
-By default, your app is deployed on a free dyno. Free dynos sleep after thirty minutes of inactivity (i.e., if they don't receive any traffic). This causes a delay of a few seconds for the first request upon waking. Subsequent requests will perform normally.
-
-Free dynos consume from a monthly, account-level quota of [free dyno hours](free-dyno-hours). As long as the quota is not exhausted, your free apps can continue to run.
-
-To avoid dyno sleeping, you can upgrade to a hobby or professional dyno type as described in [Dyno Types](dyno-types). For example, if you migrate your app to a professional dyno, you can easily scale it by running a command telling Heroku to spin up a specific number of dynos, each running your web process type.
-
-Scaling an application on Heroku is equivalent to changing the number of dynos that are running.
-
-Scale the number of web dynos to zero:
-
-```term
-:::>- $ heroku ps:scale web=0
-```
-
-Access the app again by refreshing your browser or running `heroku open`. You will get an error message because your app no longer has any web dynos available to serve requests.
-
-Scale it up again:
-
-```term
-:::>- $ heroku ps:scale web=1
-```
-
-To prevent abuse, scaling a non-free application to more than one dyno requires [account verification](account-verification).
-
-Declare app dependencies
-
-Heroku automatically identifies an app as a Java app if it contains a `pom.xml` file in the root directory. You can create a `pom.xml` file for your own apps with the `mvn archetype:create` command.
-
-The demo app you deployed already has a `pom.xml` ([see it here](https://github.com/heroku/java-getting-started/blob/master/pom.xml)). Here's an excerpt:
-
-```xml
-:::-> $ sed -n '27,35p' pom.xml
-```
-
-The `pom.xml` file specifies dependencies that should be installed with your application. When an app is deployed, Heroku reads this file and installs the dependencies by running `mvn clean install`.
-
-Another file, `system.properties`, indicates the version of Java to use (Heroku supports many [different versions](java-support#supported-java-versions)). The contents of this optional file are straightforward:
-
-```
-:::-> $ cat system.properties
-```
-
-Run `mvn clean install` in your local directory to install the dependencies, preparing your system for running the app locally. Note that this app requires Java 8, but you can push your own apps using a different version of Java.
-
-```term
-:::>- $ mvn clean install
-:::-> | $ (echo "..."; tail -7)
-```
-
-If you do not have Maven installed, or get an error like `'mvn' is not recognized as an internal or external command`, then you can use the wrapper command instead by running `mvnw clean install` on Windows or `./mvnw clean install` on Mac and Linux. This both installs Maven and runs the Maven command.
-
-The Maven process compiles and build a JAR, with dependencies, placing it into your application's `target` directory. This process is accomplished with the `spring-boot-maven-plugin` in the `pom.xml`.
-
-If you aren't using Spring in your app, you can accomplish this with the following plugin configuration in the `pom.xml` file.
-
-```xml
-
- maven-assembly-plugin
- 3.0.0
-
-
- jar-with-dependencies
-
- helloworld
-
-
-```
-
-Once dependencies are installed, you can run your app locally.
-
-Run the app locally
-
-Start your application locally with the `heroku local` CLI command (make sure you've already run `mvn clean install`):
-
-```term
-:::>- background.start("heroku local web", name: "local1", wait: "Tomcat started", timeout: 30)
-:::-> | $ (echo "..."; tail -4)
-:::-- background.stop(name: "local1")
-```
-
-Just like the Heroku platform, `heroku local` examines your `Procfile` to determine what command to run.
-
-Open [http://localhost:5000](http://localhost:5000) with your web browser. You should see your app running locally.
-
-To stop the app from running locally, go back to your terminal window and press `CTRL+C` to exit.
-
-Push local changes
-
-In this step you'll learn how to make local changes to your app and deploy them to Heroku. As an example, you'll add a dependency and some code that uses it.
-
-Modify `pom.xml` to include a dependency for `jscience` by adding the following code inside the `` element:
-
-```xml
-:::>> file.append pom.xml#28
-
- org.jscience
- jscience
- 4.3.1
-
-```
-
-Now add the following `import` statements to `src/main/java/com/example/Main.java` to import the library:
-
-```java
-:::>> file.append src/main/java/com/example/Main.java#19
-import static javax.measure.unit.SI.KILOGRAM;
-import javax.measure.quantity.Mass;
-import org.jscience.physics.model.RelativisticModel;
-import org.jscience.physics.amount.Amount;
-```
-
-Add the following `hello ` method to `Main.java`:
-
-```java
-:::>> file.append src/main/java/com/example/Main.java#59
-@RequestMapping("/hello")
-String hello(Map model) {
- RelativisticModel.select();
- Amount m = Amount.valueOf("12 GeV").to(KILOGRAM);
- model.put("science", "E=mc^2: 12 GeV = " + m.toString());
- return "hello";
-}
-```
-
-Finally, create a `src/main/resources/templates/hello.html` file with these contents:
-
-```xml
-:::>> file.write src/main/resources/templates/hello.html
-
-
-
-
-
-
-```
-
-[Here's the final source code](https://github.com/heroku/java-getting-started/blob/localchanges/src/main/java/com/example/Main.java) for `Main.java` - yours should look similar. [Here's a diff](https://github.com/heroku/java-getting-started/compare/localchanges) of all the local changes you should have made.
-
-Now test your changes locally:
-
-```term
-:::>- $ mvn clean install
-:::-> | $ (echo "..."; tail -7)
-:::>- background.start("heroku local web", name: "local2", wait: "Tomcat started", timeout: 30)
-:::-> | $ (echo "..."; tail -4)
-:::-- background.stop(name: "local2")
-```
-
-Visiting your application's `/hello` path at [http://localhost:5000/hello](http://localhost:5000/hello), you should see some great scientific conversions displayed:
-
- E=mc^2: 12 GeV = (2.139194076302506E-26 ± 1.4E-42) kg
-
-Now you can deploy. Almost every Heroku deployment follows this same pattern. First, use the `git add` command to stage your modified files for commit:
-
-```term
-:::>- $ git add .
-```
-
-Next, commit the changes to the repository:
-
-```term
-:::>- $ git commit -m "Demo"
-```
-
-Now deploy, just as you did previously:
-
-```term
-:::>- $ git push heroku master
-```
-
-Finally, check that your updated code is successfully deployed:
-
-```term
-:::>- $ heroku open hello
-```
-
-Define config vars
-
-Heroku lets you externalize your app's configuration by storing data such as encryption keys or external resource addresses in [config vars](config-vars).
-
-At runtime, config vars are exposed to your app as environment variables. For example, modify `src/main/java/com/example/Main.java` so that the method obtains an energy value from the `ENERGY` environment variable:
-
-```
-:::-- $ sed -e '56,68d' src/main/java/com/example/Main.java
-```
-
-```java
-:::>> file.append("src/main/java/com/example/Main.java#56")
-@RequestMapping("/hello")
-String hello(Map model) {
- RelativisticModel.select();
- String energy = System.getenv().get("ENERGY");
- if (energy == null) {
- energy = "12 GeV";
- }
- Amount m = Amount.valueOf(energy).to(KILOGRAM);
- model.put("science", "E=mc^2: " + energy + " = " + m.toString());
- return "hello";
-}
-```
-
-Now compile the app again so that this change is integrated by running `mvn clean install`.
-
-`heroku local` automatically sets up your local environment based on the contents of the `.env` file in your app's root directory. Your sample app already includes a `.env` file with the following contents:
-
-```
-ENERGY=20 GeV
-```
-
->warning
->Your own apps should _not_ commit the `.env` file to version control, because it often includes secure credentials. Include `.env` in your repo's `.gitignore` file.
-
-If you run the app with `heroku local` and visit it at [http://localhost:5000/hello](http://localhost:5000/hello), you'll see the conversion value for 20 GeV.
-
-To set the config var on Heroku, execute the following:
-
-```term
-:::>> $ heroku config:set ENERGY="20 GeV"
-```
-
-View the config vars that are set using `heroku config`:
-
-```term
-:::>> $ heroku config
-```
-
-Deploy your updated application to Heroku to see this in action.
-
-Start a one-off dyno
-
-The `heroku run` command lets you run maintenance and administrative tasks on your app in a [one-off dyno](one-off-dynos). It can also lets you launch a REPL process attached to your local terminal for experimenting in your app's environment, or code that you deployed with your application:
-
-```term
-:::>- $ heroku run java -version
-:::-> | $ tail -4
-```
-
-If you receive an error, `Error connecting to process`, then you might need to [configure your firewall](one-off-dynos#timeout-awaiting-process).
-
-Don’t forget to type `exit` to exit the shell and terminate the dyno.
-
-Provision add-ons
-
-Add-ons are cloud services that provide additional services for your application, such as databases, logging, and monitoring.
-
-By default, Heroku stores your app's 1500 most recent log lines. However, the full log stream is available as a service, and several logging add-ons are available that provide features such as log persistence, search, and alerting.
-
-In this step you'll provision one of these logging add-ons, Papertrail.
-
-Provision the [Papertrail](papertrail) add-on like so:
-
-```term
-:::>> $ heroku addons:create papertrail
-```
-
->callout
->To help prevent abuse, provisioning an add-on requires [account verification](account-verification). If your account has not been verified, you will be directed to visit the [verification site](https://heroku.com/verify).
-
-The add-on is now deployed and configured for your application. You can list your app's active add-ons like so:
-
-```term
-:::>- $ heroku addons
-```
-
-To see this particular add-on in action, visit your application's Heroku URL a few times. Each visit generates more log messages, which should now be routed to the Papertrail add-on. Visit the Papertrail console to see the log messages:
-
-```term
-:::>- $ heroku addons:open papertrail
-```
-
-Your browser will open up a Papertrail web console that shows the latest log events. The interface lets you search and set up alerts:
-
-
-
-Use a database
-
-Heroku provides managed data services for Postgres and Redis, and the [add-on marketplace](https://elements.heroku.com/addons/categories/data-stores) provides a variety of additional data services, including MongoDB and MySQL.
-
-In this step you'll learn about the free Heroku Postgres add-on that is provisioned automatically with all Java app deploys.
-
-Heroku Postgres is itself an add-on, so you can use the `heroku addons` command for an overview of the database provisioned for your app:
-
-```term
-:::>> $ heroku addons
-```
-
-Listing your app's config vars will display the URL that your app is using to connect to the database (`DATABASE_URL`):
-
-```term
-:::>> $ heroku config
-```
-
-The `heroku pg` command provides more in-depth information on your app's Heroku Postgres databases:
-
-```term
-:::>> $ heroku pg
-```
-
-This indicates that the app has a `Hobby-dev` database (the free plan), running Postgres 9.3.3, currently with zero rows of data.
-
-The example app you deployed already has database functionality, which you can reach by visiting your app's `/db` path. For example, if your app's root URL is `https://wonderful-app-287.herokuapp.com/` then visit `https://wonderful-app-287.herokuapp.com/db`.
-
-The code to access the database is straightforward. Here's the method to insert values into a table called `tick`:
-
-```java
-:::-> $ sed -n '45,50p;78,109p' src/main/java/com/example/Main.java
-```
-
-This ensures that when you access your app using the `/db` route, a new row is added to the `tick` table, and all rows are then returned so that they can be rendered in the output.
-
-The HikariCP database connection pool is initialized with the configuration value `spring.datasource.url`, which is defined in `src/main/resources/application.properties` like this:
-
-```
-:::-> $ sed -n '1p' src/main/resources/application.properties
-```
-
-This sets `spring.datasource.url` to the value in the `JDBC_DATABASE_URL` environment variable, [set by the database add-on](articles/connecting-to-relational-databases-on-heroku-with-java), and establishes a pool of connections to the database.
-
-Deploy your changes to Heroku. Now, when you access your app's `/db` route, you will see something like this:
-
-```
-Database Output
-* Read from DB: 2014-08-08 14:48:25.155241
-* Read from DB: 2014-08-08 14:51:32.287816
-* Read from DB: 2014-08-08 14:51:52.667683
-```
-
-Assuming that you have [Postgres installed locally](heroku-postgresql#local-setup), use the `heroku pg:psql` command to connect to the remote database and see all the rows:
-
-```term
-$ heroku pg:psql
-psql (10.1, server 9.6.10)
-SSL connection (protocol: TLSv1.2, cipher: ECDHE-RSA-AES256-GCM-SHA384, bits: 256, compression: off)
-Type "help" for help.
-
-DATABASE=> SELECT * FROM ticks;
- tick
-----------------------------
-2018-03-01 20:53:27.148139
-2018-03-01 20:53:29.288995
-2018-03-01 20:53:29.957118
-2018-03-01 21:07:28.880162
-(4 rows)
-=> \q
-```
-
-Read more about [Heroku PostgreSQL](heroku-postgresql).
-
-A similar technique can be used to install [MongoDB or Redis add-ons](https://elements.heroku.com/addons/categories/data-stores).
-
-
-## Next steps
-
-Congratulations! You now know how to deploy an app, change its configuration, scale it, view logs, and attach add-ons.
-
-Here's some recommended reading to continue your Heroku journey:
-
-* [How Heroku Works](how-heroku-works) provides a technical overview of the concepts you’ll encounter while writing, configuring, deploying, and running apps.
-* The [Java category](/categories/java-support) provides more in-depth information on developing and deploying Java apps.
-* The [Deployment category](/categories/deployment) provides a variety of powerful integrations and features to help streamline and simplify your deployments.
+```
+:::-- rundoc
+email = ENV['HEROKU_EMAIL'] || `heroku auth:whoami`
+
+Rundoc.configure do |config|
+ config.project_root = "java-getting-started"
+ config.filter_sensitive(email => "developer@example.com")
+end
+```
+
+
+Introduction
+
+This tutorial will have you deploying a Java app in minutes.
+
+Hang on for a few more minutes to learn how it all works, so you can make the most out of Heroku.
+
+The tutorial assumes that you already have:
+
+* A free Heroku account
+* Java 8 installed
+* Maven 3 installed
+
+If you'd prefer to use Gradle instead of Maven, please see the [Getting Started with Gradle on Heroku](getting-started-with-gradle-on-heroku) guide.
+
+Set up
+
+>callout
+>The Heroku CLI requires **Git**, the popular version control system. If you don't already have Git installed, complete the following before proceeding:
+>
+> * Git installation
+> * First-time Git setup
+
+In this step you'll install the Heroku Command Line Interface (CLI). You use the CLI to manage and scale your applications, provision add-ons, view your application logs, and run your application locally.
+
+Download and run the installer for your platform:
+
+
+
+When installation completes, you can use the `heroku` command from your terminal.
+
+On Windows, start the Command Prompt (cmd.exe) or Powershell to access the command shell.
+
+Use the `heroku login` command to log in to the Heroku CLI:
+
+```term
+$ heroku login
+heroku: Press any key to open up the browser to login or q to exit
+ › Warning: If browser does not open, visit
+ › https://cli-auth.heroku.com/auth/browser/***
+heroku: Waiting for login...
+Logging in... done
+Logged in as me@example.com
+```
+
+This command opens your web browser to the Heroku login page. If your browser is already logged in to Heroku, simply click the **Log in** button displayed on the page.
+
+This authentication is required for both the `heroku` and `git` commands to work correctly.
+
+Note that if you’re behind a firewall that requires use of a proxy to connect with external HTTP/HTTPS services, [you can set the `HTTP_PROXY` or `HTTPS_PROXY` environment variables](articles/using-the-cli#using-an-http-proxy) in your local development environment before running the `heroku` command.
+
+Prepare the app
+
+In this step, you will prepare a sample application that's ready to be deployed to Heroku.
+
+>callout
+>If you are new to Heroku, it is recommended that you
+>complete this tutorial using the Heroku-provided sample application.
+>
+>However, if you have your own existing application that you want to deploy
+>instead, see this article
+>to learn how to prepare it for Heroku deployment.
+
+To create a local copy of a sample app that you can deploy to Heroku, execute the following commands in your local command shell or terminal:
+
+
+```term
+:::>- $ git clone https://github.com/heroku/java-getting-started
+:::>- $ cd java-getting-started
+:::-- $ git fetch
+:::-- $ git merge origin/master
+```
+
+You now have a functioning Git repository that contains a simple Java application. The application includes a `pom.xml` file, which is used by Java's dependency manager, Maven.
+
+Deploy the app
+
+In this step you'll deploy the sample app to Heroku.
+
+First, create an app on Heroku, which prepares Heroku to receive your source code:
+
+```term
+:::>> $ heroku create
+```
+
+When you create an app, a Git remote (named `heroku`) is also created and associated with your local Git repository.
+
+By default, Heroku generates a random name (in this case `warm-eyrie-9006`) for your app. You can pass a parameter to specify your own app name.
+
+Now deploy your code:
+
+```term
+:::>- $ git push heroku master
+:::-> | $ (head -6; echo "..."; tail -18)
+```
+
+The application is now deployed. Ensure that at least one instance of the app is running:
+
+```term
+:::>- $ heroku ps:scale web=1
+```
+
+Now visit the app at the URL generated by its app name. As a handy shortcut, you can open the website like so:
+
+```term
+:::>- $ heroku open
+```
+
+View logs
+
+Heroku aggregates all of the output streams from both your app and the platform's components into a single channel of time-ordered logs.
+
+View information about your running app using the `heroku logs --tail` command:
+
+```term
+:::>- background.start("heroku logs --tail", name: "tail", wait: "State changed from starting to up", timeout: 45)
+:::-> | tail -10
+:::-- background.stop(name: "tail")
+```
+
+Visit your application in the browser again to generate another log message.
+
+Press `CTRL+C` to stop streaming logs.
+
+Define a Procfile
+
+Heroku apps use a special plaintext file called the [Procfile](procfile) to explicitly declare what command should be executed to start your app.
+
+The `Procfile` in the example app you deployed looks like this:
+
+```yaml
+:::-> $ cat Procfile
+```
+
+This declares a single process type, `web`, and the command needed to run it. The name `web` is important here. It declares that this process type will be attached to Heroku's [HTTP routing](http-routing) stack, and it will be able to receive web traffic.
+
+Procfiles can contain additional process types. For example, you might declare one for a background worker that processes items off of a queue.
+
+Scale the app
+
+Right now, your app is running on a single web [dyno](dynos). A dyno is a lightweight Linux container that runs the command specified in your `Procfile`.
+
+You can check how many dynos are running using the `heroku ps` command:
+
+```term
+:::>> $ heroku ps
+```
+
+By default, your app is deployed on a free dyno. Free dynos sleep after thirty minutes of inactivity (i.e., if they don't receive any traffic). This causes a delay of a few seconds for the first request upon waking. Subsequent requests will perform normally.
+
+Free dynos consume from a monthly, account-level quota of [free dyno hours](free-dyno-hours). As long as the quota is not exhausted, your free apps can continue to run.
+
+To avoid dyno sleeping, you can upgrade to a hobby or professional dyno type as described in [Dyno Types](dyno-types). For example, if you migrate your app to a professional dyno, you can easily scale it by running a command telling Heroku to spin up a specific number of dynos, each running your web process type.
+
+Scaling an application on Heroku is equivalent to changing the number of dynos that are running.
+
+Scale the number of web dynos to zero:
+
+```term
+:::>- $ heroku ps:scale web=0
+```
+
+Access the app again by refreshing your browser or running `heroku open`. You will get an error message because your app no longer has any web dynos available to serve requests.
+
+Scale it up again:
+
+```term
+:::>- $ heroku ps:scale web=1
+```
+
+To prevent abuse, scaling a non-free application to more than one dyno requires [account verification](account-verification).
+
+Declare app dependencies
+
+Heroku automatically identifies an app as a Java app if it contains a `pom.xml` file in the root directory. You can create a `pom.xml` file for your own apps with the `mvn archetype:create` command.
+
+The demo app you deployed already has a `pom.xml` ([see it here](https://github.com/heroku/java-getting-started/blob/master/pom.xml)). Here's an excerpt:
+
+```xml
+:::-> $ sed -n '27,35p' pom.xml
+```
+
+The `pom.xml` file specifies dependencies that should be installed with your application. When an app is deployed, Heroku reads this file and installs the dependencies by running `mvn clean install`.
+
+Another file, `system.properties`, indicates the version of Java to use (Heroku supports many [different versions](java-support#supported-java-versions)). The contents of this optional file are straightforward:
+
+```
+:::-> $ cat system.properties
+```
+
+Run `mvn clean install` in your local directory to install the dependencies, preparing your system for running the app locally. Note that this app requires Java 8, but you can push your own apps using a different version of Java.
+
+```term
+:::>- $ mvn clean install
+:::-> | $ (echo "..."; tail -7)
+```
+
+If you do not have Maven installed, or get an error like `'mvn' is not recognized as an internal or external command`, then you can use the wrapper command instead by running `mvnw clean install` on Windows or `./mvnw clean install` on Mac and Linux. This both installs Maven and runs the Maven command.
+
+The Maven process compiles and build a JAR, with dependencies, placing it into your application's `target` directory. This process is accomplished with the `spring-boot-maven-plugin` in the `pom.xml`.
+
+If you aren't using Spring in your app, you can accomplish this with the following plugin configuration in the `pom.xml` file.
+
+```xml
+
+ maven-assembly-plugin
+ 3.0.0
+
+
+ jar-with-dependencies
+
+ helloworld
+
+
+```
+
+Once dependencies are installed, you can run your app locally.
+
+Run the app locally
+
+Start your application locally with the `heroku local` CLI command (make sure you've already run `mvn clean install`):
+
+```term
+:::>- background.start("heroku local web", name: "local1", wait: "Tomcat started", timeout: 30)
+:::-> | $ (echo "..."; tail -4)
+:::-- background.stop(name: "local1")
+```
+
+Just like the Heroku platform, `heroku local` examines your `Procfile` to determine what command to run.
+
+Open [http://localhost:5000](http://localhost:5000) with your web browser. You should see your app running locally.
+
+To stop the app from running locally, go back to your terminal window and press `CTRL+C` to exit.
+
+Push local changes
+
+In this step you'll learn how to make local changes to your app and deploy them to Heroku. As an example, you'll add a dependency and some code that uses it.
+
+Modify `pom.xml` to include a dependency for `jscience` by adding the following code inside the `` element:
+
+```xml
+:::>> file.append pom.xml#28
+
+ org.jscience
+ jscience
+ 4.3.1
+
+```
+
+Now add the following `import` statements to `src/main/java/com/example/Main.java` to import the library:
+
+```java
+:::>> file.append src/main/java/com/example/Main.java#19
+import static javax.measure.unit.SI.KILOGRAM;
+import javax.measure.quantity.Mass;
+import org.jscience.physics.model.RelativisticModel;
+import org.jscience.physics.amount.Amount;
+```
+
+Add the following `hello ` method to `Main.java`:
+
+```java
+:::>> file.append src/main/java/com/example/Main.java#59
+@RequestMapping("/hello")
+String hello(Map model) {
+ RelativisticModel.select();
+ Amount m = Amount.valueOf("12 GeV").to(KILOGRAM);
+ model.put("science", "E=mc^2: 12 GeV = " + m.toString());
+ return "hello";
+}
+```
+
+Finally, create a `src/main/resources/templates/hello.html` file with these contents:
+
+```xml
+:::>> file.write src/main/resources/templates/hello.html
+
+
+
+
+
+
+```
+
+[Here's the final source code](https://github.com/heroku/java-getting-started/blob/localchanges/src/main/java/com/example/Main.java) for `Main.java` - yours should look similar. [Here's a diff](https://github.com/heroku/java-getting-started/compare/localchanges) of all the local changes you should have made.
+
+Now test your changes locally:
+
+```term
+:::>- $ mvn clean install
+:::-> | $ (echo "..."; tail -7)
+:::>- background.start("heroku local web", name: "local2", wait: "Tomcat started", timeout: 30)
+:::-> | $ (echo "..."; tail -4)
+:::-- background.stop(name: "local2")
+```
+
+Visiting your application's `/hello` path at [http://localhost:5000/hello](http://localhost:5000/hello), you should see some great scientific conversions displayed:
+
+ E=mc^2: 12 GeV = (2.139194076302506E-26 ± 1.4E-42) kg
+
+Now you can deploy. Almost every Heroku deployment follows this same pattern. First, use the `git add` command to stage your modified files for commit:
+
+```term
+:::>- $ git add .
+```
+
+Next, commit the changes to the repository:
+
+```term
+:::>- $ git commit -m "Demo"
+```
+
+Now deploy, just as you did previously:
+
+```term
+:::>- $ git push heroku master
+```
+
+Finally, check that your updated code is successfully deployed:
+
+```term
+:::>- $ heroku open hello
+```
+
+Define config vars
+
+Heroku lets you externalize your app's configuration by storing data such as encryption keys or external resource addresses in [config vars](config-vars).
+
+At runtime, config vars are exposed to your app as environment variables. For example, modify `src/main/java/com/example/Main.java` so that the method obtains an energy value from the `ENERGY` environment variable:
+
+```
+:::-- $ sed -e '56,68d' src/main/java/com/example/Main.java
+```
+
+```java
+:::>> file.append("src/main/java/com/example/Main.java#56")
+@RequestMapping("/hello")
+String hello(Map model) {
+ RelativisticModel.select();
+ String energy = System.getenv().get("ENERGY");
+ if (energy == null) {
+ energy = "12 GeV";
+ }
+ Amount m = Amount.valueOf(energy).to(KILOGRAM);
+ model.put("science", "E=mc^2: " + energy + " = " + m.toString());
+ return "hello";
+}
+```
+
+Now compile the app again so that this change is integrated by running `mvn clean install`.
+
+`heroku local` automatically sets up your local environment based on the contents of the `.env` file in your app's root directory. Your sample app already includes a `.env` file with the following contents:
+
+```
+ENERGY=20 GeV
+```
+
+>warning
+>Your own apps should _not_ commit the `.env` file to version control, because it often includes secure credentials. Include `.env` in your repo's `.gitignore` file.
+
+If you run the app with `heroku local` and visit it at [http://localhost:5000/hello](http://localhost:5000/hello), you'll see the conversion value for 20 GeV.
+
+To set the config var on Heroku, execute the following:
+
+```term
+:::>> $ heroku config:set ENERGY="20 GeV"
+```
+
+View the config vars that are set using `heroku config`:
+
+```term
+:::>> $ heroku config
+```
+
+Deploy your updated application to Heroku to see this in action.
+
+Start a one-off dyno
+
+The `heroku run` command lets you run maintenance and administrative tasks on your app in a [one-off dyno](one-off-dynos). It can also lets you launch a REPL process attached to your local terminal for experimenting in your app's environment, or code that you deployed with your application:
+
+```term
+:::>- $ heroku run java -version
+:::-> | $ tail -4
+```
+
+If you receive an error, `Error connecting to process`, then you might need to [configure your firewall](one-off-dynos#timeout-awaiting-process).
+
+Don’t forget to type `exit` to exit the shell and terminate the dyno.
+
+Provision add-ons
+
+Add-ons are cloud services that provide additional services for your application, such as databases, logging, and monitoring.
+
+By default, Heroku stores your app's 1500 most recent log lines. However, the full log stream is available as a service, and several logging add-ons are available that provide features such as log persistence, search, and alerting.
+
+In this step you'll provision one of these logging add-ons, Papertrail.
+
+Provision the [Papertrail](papertrail) add-on like so:
+
+```term
+:::>> $ heroku addons:create papertrail
+```
+
+>callout
+>To help prevent abuse, provisioning an add-on requires [account verification](account-verification). If your account has not been verified, you will be directed to visit the [verification site](https://heroku.com/verify).
+
+The add-on is now deployed and configured for your application. You can list your app's active add-ons like so:
+
+```term
+:::>- $ heroku addons
+```
+
+To see this particular add-on in action, visit your application's Heroku URL a few times. Each visit generates more log messages, which should now be routed to the Papertrail add-on. Visit the Papertrail console to see the log messages:
+
+```term
+:::>- $ heroku addons:open papertrail
+```
+
+Your browser will open up a Papertrail web console that shows the latest log events. The interface lets you search and set up alerts:
+
+
+
+Use a database
+
+Heroku provides managed data services for Postgres and Redis, and the [add-on marketplace](https://elements.heroku.com/addons/categories/data-stores) provides a variety of additional data services, including MongoDB and MySQL.
+
+In this step you'll learn about the free Heroku Postgres add-on that is provisioned automatically with all Java app deploys.
+
+Heroku Postgres is itself an add-on, so you can use the `heroku addons` command for an overview of the database provisioned for your app:
+
+```term
+:::>> $ heroku addons
+```
+
+Listing your app's config vars will display the URL that your app is using to connect to the database (`DATABASE_URL`):
+
+```term
+:::>> $ heroku config
+```
+
+The `heroku pg` command provides more in-depth information on your app's Heroku Postgres databases:
+
+```term
+:::>> $ heroku pg
+```
+
+This indicates that the app has a `Hobby-dev` database (the free plan), running Postgres 9.3.3, currently with zero rows of data.
+
+The example app you deployed already has database functionality, which you can reach by visiting your app's `/db` path. For example, if your app's root URL is `https://wonderful-app-287.herokuapp.com/` then visit `https://wonderful-app-287.herokuapp.com/db`.
+
+The code to access the database is straightforward. Here's the method to insert values into a table called `tick`:
+
+```java
+:::-> $ sed -n '45,50p;78,109p' src/main/java/com/example/Main.java
+```
+
+This ensures that when you access your app using the `/db` route, a new row is added to the `tick` table, and all rows are then returned so that they can be rendered in the output.
+
+The HikariCP database connection pool is initialized with the configuration value `spring.datasource.url`, which is defined in `src/main/resources/application.properties` like this:
+
+```
+:::-> $ sed -n '1p' src/main/resources/application.properties
+```
+
+This sets `spring.datasource.url` to the value in the `JDBC_DATABASE_URL` environment variable, [set by the database add-on](articles/connecting-to-relational-databases-on-heroku-with-java), and establishes a pool of connections to the database.
+
+Deploy your changes to Heroku. Now, when you access your app's `/db` route, you will see something like this:
+
+```
+Database Output
+* Read from DB: 2014-08-08 14:48:25.155241
+* Read from DB: 2014-08-08 14:51:32.287816
+* Read from DB: 2014-08-08 14:51:52.667683
+```
+
+Assuming that you have [Postgres installed locally](heroku-postgresql#local-setup), use the `heroku pg:psql` command to connect to the remote database and see all the rows:
+
+```term
+$ heroku pg:psql
+psql (10.1, server 9.6.10)
+SSL connection (protocol: TLSv1.2, cipher: ECDHE-RSA-AES256-GCM-SHA384, bits: 256, compression: off)
+Type "help" for help.
+
+DATABASE=> SELECT * FROM ticks;
+ tick
+----------------------------
+2018-03-01 20:53:27.148139
+2018-03-01 20:53:29.288995
+2018-03-01 20:53:29.957118
+2018-03-01 21:07:28.880162
+(4 rows)
+=> \q
+```
+
+Read more about [Heroku PostgreSQL](heroku-postgresql).
+
+A similar technique can be used to install [MongoDB or Redis add-ons](https://elements.heroku.com/addons/categories/data-stores).
+
+
+## Next steps
+
+Congratulations! You now know how to deploy an app, change its configuration, scale it, view logs, and attach add-ons.
+
+Here's some recommended reading to continue your Heroku journey:
+
+* [How Heroku Works](how-heroku-works) provides a technical overview of the concepts you’ll encounter while writing, configuring, deploying, and running apps.
+* The [Java category](/categories/java-support) provides more in-depth information on developing and deploying Java apps.
+* The [Deployment category](/categories/deployment) provides a variety of powerful integrations and features to help streamline and simplify your deployments.
diff --git a/etc/postgresql/db-createdb-and-user.sql b/etc/development/db-createdb-and-user.sql
similarity index 100%
rename from etc/postgresql/db-createdb-and-user.sql
rename to etc/development/db-createdb-and-user.sql
diff --git a/etc/engineering/Engineering.md b/etc/engineering/Engineering.md
deleted file mode 100644
index 961cac4d..00000000
--- a/etc/engineering/Engineering.md
+++ /dev/null
@@ -1 +0,0 @@
-# Engineering
diff --git a/etc/requirements/Nonfunctional_Requirements.md b/etc/requirements/Nonfunctional_Requirements.md
new file mode 100644
index 00000000..2fa851dd
--- /dev/null
+++ b/etc/requirements/Nonfunctional_Requirements.md
@@ -0,0 +1,30 @@
+# Nonfunctional Requirements
+
+## NF001 Runtime Components
+### PostgreSQL Database
+### PostgreSQL Database CLI
+### Embedded java Servlet Container (Apache Tomcat)
+### spring-boot
+### spring-boot-web
+### spring-boot-jpa
+### spring-session-jdbc
+## NF002 Development Systems: Local Machine
+### Windows10
+### Linux
+### bash
+### git
+### java
+### maven
+### Database PostgreSQL
+#### Docker
+#### Local Service
+### IDE
+#### IntelliJ
+#### SpringToolSuite in Eclipse
+## NF003 Development Systems: Github
+## NF004 Development Systems: Continous Integration Service
+## NF004 Development Systems: Heroku
+## NF005 Continous Integration: Spring/Maven Unit and Integration Tests
+## NF007 Deployment on Heroku
+## NF007 Deployment on Heroku: Database Schema Changes
+
diff --git a/etc/requirements/requirements.odt b/etc/requirements/Nonfunctional_Requirements.odt
similarity index 100%
rename from etc/requirements/requirements.odt
rename to etc/requirements/Nonfunctional_Requirements.odt
diff --git a/etc/requirements/requirements.md b/etc/requirements/Requirements.md
similarity index 86%
rename from etc/requirements/requirements.md
rename to etc/requirements/Requirements.md
index 387183a7..e2b6ef15 100644
--- a/etc/requirements/requirements.md
+++ b/etc/requirements/Requirements.md
@@ -1,6 +1,4 @@
-# Requirements
-
-# User Stories
+# Functional Requirements
## F001 Server Starts
@@ -20,5 +18,3 @@
-
-
diff --git a/etc/requirements/Requirements.odt b/etc/requirements/Requirements.odt
new file mode 100644
index 00000000..301152ff
Binary files /dev/null and b/etc/requirements/Requirements.odt differ
diff --git a/etc/requirements/uml/SimpleWorklist.mdzip b/etc/requirements/uml/SimpleWorklist.mdzip
deleted file mode 100644
index c44bb044..00000000
Binary files a/etc/requirements/uml/SimpleWorklist.mdzip and /dev/null differ
diff --git a/etc/engineering/uml/SimpleWorklist.mdzip b/etc/uml/SimpleWorklist.mdzip
similarity index 100%
rename from etc/engineering/uml/SimpleWorklist.mdzip
rename to etc/uml/SimpleWorklist.mdzip
diff --git a/run.sh b/run.sh
index 157a44d7..bd8cafd3 100755
--- a/run.sh
+++ b/run.sh
@@ -2,8 +2,6 @@
source setenv.sh
-
-
function runDev() {
./mvnw
}
macOS
-
- 
Windows
- 
Ubuntu 16+
-