a:6:{i:0;s:8468:"					<section class="headBg theme2 ">
					<div class="wrap">
					<div class="page-title-inner fo"> 
					<div class="h1"><h1>Job openings for account executive in surat</h1></div>
					<p class="breadcrumb ar uu small"><a href="http://www.jenishfood.com/" title="Home">Home</a>
					
											<b class="ffv p2px">&rsaquo;</b><a href="http://www.jenishfood.com/current-openings.htm" title="Current Openings">Current Openings</a>
																
					<b class="ffv p2px">&rsaquo;</b> Job openings for account executive in surat</p>
					</div>
					</div>
					</section>
									<section id="middle">
				<div class="wrap" id="bodyFormatNT">
				<div class="row1 dt columns23"><!--MIDDLE ROW1 STARTS-->
				<div class="col-2 wideColumn ip ls detail_pm_15"><!--MIDDLE ROW1 COL-2 STARTS-->
				
								<div class="pt10px">
				<div class="xxxlarge fw6 dif">Account Executive - Kim Office</div>
									<p class="mt7px fw6">Surat</p>
									
				<br>
				<p class="aj mt7px">Job Description <br />
<br />
- Verify, allocate, post and reconcile accounts payable and receivable<br />
- Produce error-free accounting reports and present their results<br />
- Analyze financial information and summarize financial status<br />
- Spot errors and suggest ways to improve efficiency and spending<br />
- Provide technical support and advice on Management accountant<br />
- Follow Terms of the employment, should be known about Taxation, Reporting, Collection Follow up <br />
   From sales team or others<br />
- Review and recommend modifications to accounting systems and procedures<br />
- Manage accounting assistants and book keepers<br />
- Prepare financial statements and produce budget according to schedule<br />
- Assist with tax audits and tax returns<br />
- Direct internal and external audits to ensure compliance<br />
- Plan, assign and review staff’s work<br />
- Support month-end and year-end close process<br />
- Develop and document business processes and accounting policies to maintain and strengthen internal <br />
   Controls<br />
- Liaise with our financial manager and Accounting manager to improve financial procedures<br />
- Prepare, examine, or analyses accounting records, financial statements, or other financial reports to   <br />
   Assess accuracy, completeness, and conformance to reporting and procedural standards<br />
- Report to management regarding the finances of establishment<br />
- Establish tables of accounts and assign entries to proper accounts<br />
- Develop, implement, modify, and document recordkeeping and accounting systems, making use of <br />
   Current technology<br />
- Compute taxes owed and prepare tax returns, ensuring compliance with payment, reporting or other tax <br />
   Requirements<br />
- To manage all Rules Of employment without any mistake<br />
- Follow Dress code, Badge or ID proof while working hours<br />
- Develop, implement, modify, and document recordkeeping and accounting systems, making use of <br />
   Current technology<br />
- Compute taxes owed and prepare tax returns, ensuring compliance with payment, reporting or other tax <br />
   Requirements</p>
				
				<table class="w100 formTable bdr0 mt20px">	
				<tr>
				<td class="w195 alpha75 p5px">Experience</td>
				<td class="p5px">1 - 5 Years</td>
				</tr>			
									<tr>
					<td class="alpha75 p5px">Salary</td>
					<td class="p5px">Not Disclosed</td>
					</tr>
									
					<tr>
					<td class="alpha75 p5px">Industry</td>
					<td class="p5px">Accounting / Auditing / Taxation</td>
					</tr>
									
									<tr>
					<td class="alpha75 p5px">Qualification</td>
					<td class="p5px">Professional Degree, Other Bachelor Degree, B.Com, MD/Medicinae Doctor, Post Graduate Diploma, M.Com</td>
					</tr>					
										<tr>
					<td class="alpha75 p5px">Key Skills</td>
					<td class="p5px">
											<span class="bdr dib p2px10px mr5px mt2px">Tally</span>
												<span class="bdr dib p2px10px mr5px mt2px"> Accounting</span>
												<span class="bdr dib p2px10px mr5px mt2px">  Account Management</span>
												<span class="bdr dib p2px10px mr5px mt2px"> Finance</span>
											</td>
					</tr>
									
				</table>
				</div>
				<br>
				<div class="pt20px">
				<p class="large fw6">About Company</p>
				<div class="mt10px">
				
				Jenish Incorporation is a reliable manufacturer, supplier, and exporter of food products. The company was founded in Surat (Gujarat) back in the year 1994. We are known as a manufacturer, supplier, and exporter of jaljira powder, taste plus powder, pachak amla and many more. The company’s core values are the provision of excellent quality food items by satisfying all customers. Moreover, we also believe in upholding the commitment and improve the production method. We are visionary and aim at the various things 20 years from now and it includes annual growth by 50%. Furthermore, we also see ourselves as a global instigator in this industry with 50 branch offices in 7 Asian countries, manufacturing/supplying/exporting 150+ products, teams of 3000 deft professionals, annual turnover of 1,414 crores, and one toll-free number in every country.				
				<br />
				
									
					<div class="bdrT pt20px">
					<form name="frmvacdetail" method="post" action="enquiry-form-10009.htm">
					<input style="padding:7px 15px;" class="button b ffos" type="submit" value="APPLY NOW !" />
					<input type="hidden" name="catalog_mi" value="889733">
					<input type="hidden" name="enq_type" value="2"><input type="hidden" name="vacancy_id" value="898854"><input type="hidden" name="subject" value="Applied for Account Executive - Kim office">
					</form>
					</div>
			
									</div>
				</div>			
				
				<!--MIDDLE ROW1 COL-2 ENDS--> 
				</div>
				<div class="col-3 thinColumn"><!--MIDDLE ROW1 COL-1 STARTS-->
				
				<div class="column_Box mc">
				<div class="tcl bullet divider">
				<div class="large fw6 alpha75 p12px bdrB">
				<h2>Jobs by Location</h2>
				</div>
				<div class="ic">
				<div class="mt10px">
									<span class="dib p5px10px c2px bdr mr7px mb7px "><a class="dif" href="jobs-in-surat.htm" title="Jobs in Surat">Surat</a> <b class="alpha50 bn small">(8)</b></span>
									</div>
				</div>
				</div>
				</div>
				
				<div class="column_Box mc">
				<div class="tcl bullet divider">
				<div class="large fw6 alpha75 p12px bdrB">
				<h2>Jobs by Functional Area</h2>
				</div>
				<div style="padding:10px 18px;" class="ic">
									<p class="mb5px "><span class="fr">(5)</span><a href="jobs-in-sales-marketing-fid.htm" title="Sales/Marketing Jobs">Sales/Marketing</a></p>
										<p class="mb5px "><span class="fr">(1)</span><a href="jobs-in-advertisement-marketing-fid.htm" title="Marketing / Advertising / PR / Media Planning Jobs">Marketing / Advertising / PR /...</a></p>
										<p class="mb5px "><span class="fr">(1)</span><a href="jobs-in-front-office-data-entry-fid.htm" title="Front Office / Executive Assistant / Data Entry Jobs">Front Office / Executive Assis...</a></p>
										<p class="mb5px "><span class="fr">(1)</span><a href="jobs-in-accounting-tax-fid.htm" title="Accounting / Auditing / Taxation Jobs">Accounting / Auditing / Taxati...</a></p>
									
				</div>
				</div>
				</div>
				
				</div>
				<!--MIDDLE ROW1 COL-1 ENDS-->
				
				<!--MIDDLE ROW1 ENDS--> 
				</div>
				<br><br>
				</div>
				</section>
				<script>
					window.addEventListener("DOMContentLoaded", function(){
						jQuery(document).on("click", ".showallspan", function(){
							if(jQuery(this).attr("data-target") === 'show'){
								jQuery(this).text("View Less");
								jQuery(this).attr("data-target", "hide");
								jQuery(this).closest("div").find(".spanlist").removeClass("dn");
							}else{
								jQuery(this).text("View More");
								jQuery(this).attr("data-target", "show");
								jQuery(this).closest("div").find(".spanlist").addClass("dn");
							}
						});
					});
				</script>
					<script>
	$.ajax({
	  url: "https://www.placementindia.com/job_posting_view.php",
	  type: "POST",
	  dataType: 'html',
	  data: {job_view_id: 'LzdPS3kzQSt2UmlmMWR3TkxEUlhhQT09',data_type: 'RExzRmw1cmRsdlh6YkJlVUZBNnA4UT09'},
	  cache : false,
	  async: true
	  
	}).done(function(resp) {
	  //alert(resp)
	});
	</script>
	";i:1;s:66:"Job openings for account executive in surat | Jenish Incorporation";i:2;s:220:"Account Executive - Kim office Jobs,Account Executive - Kim office Jobs in Surat,Account Executive - Kim office Vacancy in Surat,Account Executive - Kim office jobs in India,Accounting / Auditing / Taxation jobs in Surat";i:3;s:297:"Apply for Account Executive - Kim office Jobs in Surat India - Account Executive - Kim office Vacancy  in Accounting / Auditing / Taxation field with 1 to 5 years Work Experience, Key Skills are Tally, Accounting,  Account Management, Finance, Accounting / Auditing / Taxation jobs in Surat  India";i:4;s:2829:"
		<script type="application/ld+json">
		{
		  "@context": "http://schema.org",
		  "@type": "JobPosting",
		  "title": "Account Executive - Kim office",
		  "baseSalary": "",
		  "description": "Job Description 

- Verify, allocate, post and reconcile accounts payable and receivable
- Produce error-free accounting reports and present their results
- Analyze financial information and summarize financial status
- Spot errors and suggest ways to improve efficiency and spending
- Provide technical support and advice on Management accountant
- Follow Terms of the employment, should be known about Taxation, Reporting, Collection Follow up 
   From sales team or others
- Review and recommend modifications to accounting systems and procedures
- Manage accounting assistants and book keepers
- Prepare financial statements and produce budget according to schedule
- Assist with tax audits and tax returns
- Direct internal and external audits to ensure compliance
- Plan, assign and review staff’s work
- Support month-end and year-end close process
- Develop and document business processes and accounting policies to maintain and strengthen internal 
   Controls
- Liaise with our financial manager and Accounting manager to improve financial procedures
- Prepare, examine, or analyses accounting records, financial statements, or other financial reports to   
   Assess accuracy, completeness, and conformance to reporting and procedural standards
- Report to management regarding the finances of establishment
- Establish tables of accounts and assign entries to proper accounts
- Develop, implement, modify, and document recordkeeping and accounting systems, making use of 
   Current technology
- Compute taxes owed and prepare tax returns, ensuring compliance with payment, reporting or other tax 
   Requirements
- To manage all Rules Of employment without any mistake
- Follow Dress code, Badge or ID proof while working hours
- Develop, implement, modify, and document recordkeeping and accounting systems, making use of 
   Current technology
- Compute taxes owed and prepare tax returns, ensuring compliance with payment, reporting or other tax 
   Requirements",
		  "educationRequirements": "Professional Degree, Other Bachelor Degree, B.Com, MD/Medicinae Doctor, Post Graduate Diploma, M.Com",
		  "experienceRequirements": "1 - 5 Years",
		  "industry": "Accounting / Auditing / Taxation",
		  "jobLocation": {
		    "@type": "Place",
		    "address": {
		      "@type": "PostalAddress",
		      "addressLocality": "Gujarat",
		      "addressRegion": "Surat"
		    }
		  },
		 "qualifications": "Professional Degree, Other Bachelor Degree, B.Com, MD/Medicinae Doctor, Post Graduate Diploma, M.Com",
		     "skills": "Tally, Accounting,  Account Management, Finance"
		  }
		</script>
		";i:5;N;}