diff --git a/accounts/doctype/sales_invoice/pos.js b/accounts/doctype/sales_invoice/pos.js
index ce3784a..1d58f2d 100644
--- a/accounts/doctype/sales_invoice/pos.js
+++ b/accounts/doctype/sales_invoice/pos.js
@@ -19,8 +19,10 @@
 							<table class="table table-condensed table-hover" id="cart" style="table-layout: fixed;">\
 								<thead>\
 									<tr>\
-										<th style="width: 50%">Item</th>\
-										<th style="width: 25%; text-align: right;">Qty</th>\
+										<th style="width: 40%">Item</th>\
+										<th style="width: 9%"></th>\
+										<th style="width: 17%; text-align: right;">Qty</th>\
+										<th style="width: 9%"></th>\
 										<th style="width: 25%; text-align: right;">Rate</th>\
 									</tr>\
 								</thead>\
@@ -357,8 +359,18 @@
 
 			$(repl('<tr id="%(item_code)s" data-selected="false">\
 					<td>%(item_code)s%(item_name)s</td>\
-					<td><input type="text" value="%(qty)s" \
+					<td style="vertical-align:middle;" align="right">\
+						<div class="decrease-qty" style="cursor:pointer;">\
+							<i class="icon-minus-sign icon-large text-danger"></i>\
+						</div>\
+					</td>\
+					<td style="vertical-align:middle;"><input type="text" value="%(qty)s" \
 						class="form-control qty" style="text-align: right;"></td>\
+					<td style="vertical-align:middle;cursor:pointer;">\
+						<div class="increase-qty" style="cursor:pointer;">\
+							<i class="icon-plus-sign icon-large text-success"></i>\
+						</div>\
+					</td>\
 					<td style="text-align: right;"><b>%(amount)s</b><br>%(rate)s</td>\
 				</tr>',
 				{
@@ -370,6 +382,11 @@
 				}
 			)).appendTo($items);
 		});
+
+		this.wrapper.find(".increase-qty, .decrease-qty").on("click", function() {
+			var item_code = $(this).closest("tr").attr("id");
+			me.selected_item_qty_operation(item_code, $(this).attr("class"));
+		});
 	},
 	show_taxes: function() {
 		var me = this;
@@ -501,6 +518,22 @@
 		this.frm.script_manager.trigger("calculate_taxes_and_totals");
 		this.refresh();
 	},
+	selected_item_qty_operation: function(item_code, operation) {
+		var me = this;
+		var child = wn.model.get_children(this.frm.doctype + " Item", this.frm.doc.name, 
+			this.frm.cscript.fname, this.frm.doctype);
+
+		$.each(child, function(i, d) {
+			if (d.item_code == item_code) {
+				if (operation == "increase-qty")
+					d.qty += 1;
+				else if (operation == "decrease-qty")
+					d.qty != 1 ? d.qty -= 1 : d.qty = 1;
+
+				me.refresh();
+			}
+		});
+	},
 	make_payment: function() {
 		var me = this;
 		var no_of_items = $(this.wrapper).find("#cart tbody tr").length;
diff --git a/config.json b/config.json
index 8499ee8..8e033d5 100644
--- a/config.json
+++ b/config.json
@@ -1,6 +1,6 @@
 {
  "app_name": "ERPNext", 
- "app_version": "3.5.1", 
+ "app_version": "3.6.0", 
  "base_template": "app/portal/templates/base.html", 
  "modules": {
   "Accounts": {
@@ -74,5 +74,5 @@
    "type": "module"
   }
  }, 
- "requires_framework_version": "==3.5.0"
+ "requires_framework_version": "==3.7.0"
 }
\ No newline at end of file
