a:4:{i:0;s:5421:"				
				<p class="xxlarge b bdrB orange ffv">Medical Officer</p>
				<p class="ar mb15px">&bull; <a href="http://www.z2plus.co.in/">Home</a> &bull; Medical Officer</p>
				<div class="vacancy">
				<p class="bdrB b dif mb10px"><b class="ffv">&raquo;</b> VACANCY DETAILS</p>
				<table class="w95 bdrAll small">
				<tr>
				<td class="w30 data p5px pl7px">Job Title </td>
				<td class="p5px pl10px w1px">:</td>
				<td class="w70 p5px pl7px">Medical Officer</td>
				</tr>
				
									
					<tr>
					<td class="data p5px pl7px"> Gender Preference </td>
					<td class="p5px pl10px">:</td>
					<td class=" p5px pl7px">Any</td>
					</tr>
					
										
					<tr>
					<td class="data p5px pl7px"> Number Of Vacancy </td>
					<td class="p5px pl10px">:</td>
					<td class=" p5px pl7px">6</td>
					</tr>
					
										
					<tr>
					<td class="data p5px pl7px"> Industry Area </td>
					<td class="p5px pl10px">:</td>
					<td class=" p5px pl7px">Medical / Health Care / Hospitals </td>
					</tr>
					
										
					<tr>
					<td class="data p5px pl7px"> Key Skills </td>
					<td class="p5px pl10px">:</td>
					<td class=" p5px pl7px">Medical officer </td>
					</tr>
					
										
					<tr>
					<td class="data p5px pl7px"> Qualification </td>
					<td class="p5px pl10px">:</td>
					<td class=" p5px pl7px">MBBS </td>
					</tr>
					
											
						<tr>
						<td class="data p5px pl7px"> Salary (Per Annum) </td>
						<td class="p5px pl10px">:</td>
						<td class=" p5px pl7px"> 4  Lac  To  6  Lac  50 Thousand  </td>
						</tr>
						
											
					<tr>
					<td class="data p5px pl7px"> Work Experience </td>
					<td class="p5px pl10px">:</td>
					<td class=" p5px pl7px">0 - 6 Years</td>
					</tr>
					
										
					<tr>
					<td class="data p5px pl7px"> Job Requirement </td>
					<td class="p5px pl10px">:</td>
					<td class=" p5px pl7px">We have Immediate Job Vacancies for Mbbs Doctors, Please Find the Job Details Below.<br />
<br />
job Profile and Job Description:<br />
<br />
job Locations: Ap(andhra Pradesh) Ananthapur.<br />
<br />
job Description:<br />
<br />
kra for Team Doctor Minimum Qualification: Mbbs (mci Registered)<br />
<br />
1. Supervision of Proper Implementation of Health Care Activities in Mobile Medical Unit.<br />
<br />
2. Provide Preventive and Curative Care to the Community.<br />
<br />
3. Referral of Complicated Cases to Higher Health Facilities with Adequate Facilities.<br />
<br />
4. Make Sure that De-worming & Immunization Awareness.<br />
<br />
5. Supervision of other Staff Functions & Act as Overall Team Leader.<br />
<br />
6. Update to Head Office About Any Major Health Traits in the Community.<br />
<br />
7. Send Sms of Daily Reporting.<br />
<br />
8. Sending Attendance Sms Daily No Later Than 10 Am.<br />
<br />
9. Health Education & Counseling as & When Required.<br />
<br />
10. Ensuring Whole Team Fulfills Its Kras 11. Work for At Least 3 Hrs per Day At Each Designated Village (totaling a Minimum of 7 Hrs)<br />
<br />
12. Submission of Register No Later Than 25th of the Month (through Coordinator) 13. Get all Approvals from Local Government Authorities </td>
					</tr>					
									
				</table>
				</div>
				<br />
				<br />
				<p class="bdrB b dif mb10px"><b class="ffv">&raquo;</b> JOB LOCATION</p>
				<table class="w95 bdrAll small">
				
									
					<tr>
					<td class="w30 data p5px pl7px">Job Country </td>
					<td class="p5px pl10px w1px">:</td>
					<td class="w70 p5px pl7px">India</td>
					</tr>
					
										
					<tr>
					<td class="data p5px pl7px">Job State / U.T.</td>
					<td class="p5px pl10px">:</td>
					<td class=" p5px pl7px">Andhra Pradesh</td>
					</tr>
					
									
				</table>
				
								<br />
				<br />
				<p class="bdrB b dif mb10px"><b class="ffv">&raquo;</b> CONTACT DETAILS</p>
				<table class="w95 bdrAll small">
				
									
					<tr>
					<td class="w30 data p5px pl7px">Contact Person</td>
					<td class="p5px pl10px w1px">:</td>
					<td class="w70 p5px pl7px">Shiv Bahadur Singh</td>
					</tr>
					
										
					<tr>
					<td class="w30 data p5px pl7px">Address </td>
					<td class="p5px pl10px w1px">:</td>
					<td class="w70 p5px pl7px">310, CR Avenue, Girish Park, Metro , Kolkata West Bengal ( Pin Code: 700006), India </td>
					</tr>
					
										
					<tr>
					<td class="w30 data p5px pl7px">Mobile </td>
					<td class="p5px pl10px w1px">:</td>
					<td class="w70 p5px pl7px">9230532520 </td>
					</tr>
					
										
					<tr>
					<td class="w30 data p5px pl7px">Email ID </td>
					<td class="p5px pl10px w1px">:</td>
					<td class="w70 p5px pl7px"><a href="mailto:hrz2pluskol@gmail.com"> hrz2pluskol@gmail.com </a> </td>
					</tr>
					
									
				</table>
				
									
					<br class="lh1em" />
					<div class="ac">
					<form name="frmvacdetail" method="post" action="enquiry-form-10009.htm">
					<input class="button" type="submit" value="APPLY NOW !" />
					<input type="hidden" name="catalog_mi" value="333266">
					<input type="hidden" name="enq_type" value="2"><input type="hidden" name="vacancy_id" value="834792"><input type="hidden" name="subject" value="Applied for Medical Officer">
					</form>
					</div>
			
									
				<br />
				
				";i:1;s:85:"Medical Officer Jobs in Andhra Pradesh - Vacancy in Medical / Health Care / Hospitals";i:2;s:146:"Medical Officer Jobs,Medical Officer Jobs in ,Medical Officer Vacancy in ,Medical Officer jobs in India,Medical / Health Care / Hospitals jobs in ";i:3;s:227:"Apply for Medical Officer Jobs in  India - Medical Officer Vacancy  in Medical / Health Care / Hospitals field with 0 to 6 years Work Experience, Key Skills are Medical officer, Medical / Health Care / Hospitals jobs in   India";}