docs: function (options, cb) {
  		/**
  		 ==> service found in project
  		 //service already has a load balancer
  		 ==> case 1: ports in recipe are different than load balancer
  		 ==> trigger update load balancer exposed ports
  		 ==> case 2: ports in recipe are the same in load balancer
  		 ==> don’t do anything
  		 ==> case 3: no exposed ports in recipe but load balancer has exposed ports
  		 ==> delete load balancer
  		 
  		 ==> service not found in project
  		 ==> case1: service has no load balancer, creating load balancer for the first time
  		 ==> case2: service has no load balancer, but it is being redeployed with exposed ports
  		 ==> iza fi exposed ports aw ispublished true, then create and expose load balancer
  		 * */
  			
  			//get the service
  		let service = options.params.name;
  		let ports = options.params.ports;
  		const stack = options.infra.stack;
  		const envCode = options.params.envCode.toUpperCase();
  		
  		options.params.info = options.infra.info;
  		let listeners = [];
  		options.params.ElbName = null;
  		if (stack.loadBalancers && options.params.envCode.toUpperCase() && stack.loadBalancers[options.params.envCode.toUpperCase()] && stack.loadBalancers[options.params.envCode.toUpperCase()][service]) {
  			options.params.ElbName = stack.loadBalancers[options.params.envCode.toUpperCase()][service];
  		}
  		if (ports.length === 0 && !options.params.ElbName) {
  			return cb(null, true);
  		}
  		if (ports[0] && ports[0].published) {
  			for (let i = 0; i < ports.length; i++) {
  				let listener = {
  					backendPort: ports[i].published,
  					backendProtocol: "TCP",
  					frontendPort: ports[i].target,
  					frontendProtocol: "TCP",
  				};
  				if (ports[i].target === 80) {
  					listener.frontendProtocol = 'HTTP';
  					listener.backendProtocol = 'HTTP';
  				}
  				listeners.push(listener);
  			}
  		}
  		
  		options.params.region = stack.options.zone;
  		options.params.rules = listeners;
  		//service is found in project record
  		if (options.params.ElbName) {
  			//service have ports to be exposed
  			//update listeners
  			
  			if (listeners.length > 0) {
  				AWSLB.updateExternalLB(options, function (err) {
  					return cb(err, true);
  				});
  			}
  			//service have no ports to be exposed
  			//delete load balancer
  			else {
  				if (!options.params.ElbName.name) {
  					return cb(null, true);
  				}
  				else {
  					options.params.name = options.params.ElbName.name;
  				}
  				AWSLB.delete(options, function (err) {
  					if (err) {
  						return cb(err);
  					}
  					else {
  						options.params.info = options.infra.info;
  						const envCode = options.params.envCode.toUpperCase();
  						options.params.name = service;
  						if (options.infra.deployments && options.infra.deployments[options.params.info[2]]
  							&& options.infra.deployments[options.params.info[2]].loadBalancers
  							&& options.infra.deployments[options.params.info[2]].loadBalancers[envCode]
  							&& options.infra.deployments[options.params.info[2]].loadBalancers[envCode][service]) {
  							delete options.infra.deployments[options.params.info[2]].loadBalancers[envCode][service];
  						}
  						return cb(null, true);
  					}
  				});
  			}
  		}
  		//service is not found in project record
  		else {
  			//service have ports to be exposed
  			if (listeners.length > 0) {
  				if (!options.params.info || options.params.info.length === 0) {
  					return cb(new Error("Did not find any deployment information in infra details provided!"));
  				}
  				const aws = options.infra.api;
  				const ec2 = getConnector({
  					api: 'ec2',
  					region: stack.options.zone,
  					keyId: aws.keyId,
  					secretAccessKey: aws.secretAccessKey
  				});
  				const elb = getConnector({
  					api: 'elb',
  					region: stack.options.zone,
  					keyId: aws.keyId,
  					secretAccessKey: aws.secretAccessKey
  				});
  				
  				let name = `ht${options.params.soajs_project}-External-`; //ht + projectname + service name
  				
  				name += randomString.generate({
  					length: 31 - name.length,
  					charset: 'alphanumeric',
  					capitalization: 'uppercase'
  				});
  				let lbParams = {
  					rules: listeners,
  					name: name,
  					securityGroups: [
  						stack.options.ExternalLBSecurityGroupID
  					],
  					tags: [
  						{
  							Key: 'ht:cloudformation:stack-name', /* required */
  							Value: stack.name
  						},
  						{
  							Key: 'ht:cloudformation:stack-id', /* required */
  							Value: stack.id
  						},
  						{
  							Key: 'Type', /* required */
  							Value: "External"
  						},
  						{
  							Key: 'Name', /* required */
  							Value: name
  						}
  					]
  				};
  				if (stack.options.ZonesAvailable) {
  					if (!Array.isArray(stack.options.ZonesAvailable)) {
  						lbParams.subnets = [stack.options.ZonesAvailable];
  					}
  					else {
  						lbParams.subnets = stack.options.ZonesAvailable;
  					}
  				}
  				lbParams.region = stack.options.zone;
  				options.soajs.log.debug(lbParams);
  				let params = JSON.parse(JSON.stringify(options.params));
  				options.params = lbParams;
  				AWSLB.create(options, function (err, loadBalancer) {
  					if (err) {
  						return cb(err);
  					}
  					options.params = params;
  					const instanceParams = {
  						Filters: [
  							{
  								Name: 'tag:aws:cloudformation:stack-name',
  								Values: [
  									stack.name
  								]
  							}
  						]
  					};
  					let instanceIds = [];
  					ec2.describeInstances(instanceParams, function (err, instances) {
  						if (err) {
  							return cb(err);
  						}
  						else {
  							for (let i = 0; i < instances.Reservations.length; i++) {
  								for (let y = 0; y < instances.Reservations[i].Instances.length; y++) {
  									instanceIds.push({InstanceId: instances.Reservations[i].Instances[y].InstanceId});
  								}
  							}
  							if (instanceIds.length === 0) {
  								return cb(new Error("No instances found in stack"));
  							}
  							const registerParams = {
  								Instances: instanceIds,
  								LoadBalancerName: name
  							};
  							elb.registerInstancesWithLoadBalancer(registerParams, function (err) {
  								if (err) {
  									return cb(err);
  								}
  								
  								//manipulate and add the record
  								let deployment = options.infra.deployments;
  								//if no loadBalancers object found create one
  								if (!deployment[options.params.info[2]].loadBalancers) {
  									deployment[options.params.info[2]].loadBalancers = {};
  								}
  								//if no environment in loadBalancers object found create one
  								if (!deployment[options.params.info[2]].loadBalancers[envCode]) {
  									deployment[options.params.info[2]].loadBalancers[envCode] = {};
  								}
  								deployment[options.params.info[2]].loadBalancers[envCode][options.params.name] = {
  									name: name,
  									DNSName: loadBalancer.DNSName,
  									ports: options.params.ports
  								};
  								options.infra.deployments = deployment;
  								return cb(null, true);
  							});
  						}
  					});
  				});
  			}
  			else {
  				//do nothing
  				return cb(null, true);
  			}
  		}
  	}