diff --git a/pom.xml b/pom.xml
index 07e1c9f..8e6c0f8 100644
--- a/pom.xml
+++ b/pom.xml
@@ -4,7 +4,7 @@
 
 	<groupId>org.onap.sdc.jtosca</groupId>
 	<artifactId>jtosca</artifactId>
-	<version>1.4.8-SNAPSHOT</version>
+	<version>1.4.9-SNAPSHOT</version>
 	<name>sdc-jtosca</name>
 	<properties>
 
diff --git a/src/main/java/org/onap/sdc/toscaparser/api/elements/NodeType.java b/src/main/java/org/onap/sdc/toscaparser/api/elements/NodeType.java
index 07b3a87..a6d7f81 100644
--- a/src/main/java/org/onap/sdc/toscaparser/api/elements/NodeType.java
+++ b/src/main/java/org/onap/sdc/toscaparser/api/elements/NodeType.java
@@ -101,24 +101,33 @@
             				keyword = "node";
             			}
             			else {
-                            // If value is a dict and has a type key
+							String getRelation = null;
+                            // If nodeTypeByCap is a dict and has a type key
                             // we need to lookup the node type using
                             // the capability type
             				String captype = (String)req.get("capability");
-            				String value = _getNodeTypeByCap(captype);
-            				String getRelation = _getRelation(key,value);
+            				nodeType = _getNodeTypeByCap(captype);
+            				if (nodeType != null){
+								getRelation = _getRelation(key, nodeType);
+							} else {
+								ThreadLocalsHolder.getCollector().appendValidationIssue(new JToscaValidationIssue("JE11", String.format(
+										"NodeTypeForCapabilityNotFoundError: Node type for capability type \"%s\" is not found",captype)));
+							}
             				if (getRelation != null)  {
             					relation = getRelation;
             				}
             				keyword = key;
-            				nodeType = value;
             			}
             		}
-            		
             	}
-            	RelationshipType rtype = new RelationshipType(relation, keyword, customDef);
-            	NodeType relatednode = new NodeType(nodeType, customDef);
-            	relationship.put(rtype, relatednode);
+            	if(relation == null || nodeType == null){
+					ThreadLocalsHolder.getCollector().appendValidationIssue(new JToscaValidationIssue("JE11", String.format(
+							"NodeTypeForRelationNotFound: Node type \"%s\" with relationship type \"%s\" is not found",nodeType, relation)));
+				} else {
+					RelationshipType rtype = new RelationshipType(relation, keyword, customDef);
+					NodeType relatednode = new NodeType(nodeType, customDef);
+					relationship.put(rtype, relatednode);
+				}
             }
 		}
 		return relationship;
diff --git a/src/main/java/org/onap/sdc/toscaparser/api/utils/ValidateUtils.java b/src/main/java/org/onap/sdc/toscaparser/api/utils/ValidateUtils.java
index 6c26f18..9623258 100644
--- a/src/main/java/org/onap/sdc/toscaparser/api/utils/ValidateUtils.java
+++ b/src/main/java/org/onap/sdc/toscaparser/api/utils/ValidateUtils.java
@@ -12,7 +12,7 @@
 
 	public static Object strToNum(Object value) {
 	    // Convert a string representation of a number into a numeric type
-	    // tODO(TBD) we should not allow numeric values in, input should be str
+	    // TODO(TBD) we should not allow numeric values in, input should be str
 		if(value instanceof Number) {
 			return value;
 		}
diff --git a/version.properties b/version.properties
index 7a72c98..61bae76 100644
--- a/version.properties
+++ b/version.properties
@@ -5,7 +5,7 @@
 
 major=1
 minor=4
-patch=8
+patch=9
 
 base_version=${major}.${minor}.${patch}
 
