a:6:{i:0;s:8498:"				<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="h1"><h1>Job openings for accomodation manager in saudi arabia</h1></div>
					<p class="breadcrumb ar uu small"> <a href="https://www.taexpo.in/">Home</a>
					
											<b class="ffv p2px">&rsaquo;</b><a href="https://www.taexpo.in/current-jobs.htm" title="Current Jobs">Current Jobs</a>  			
											
					<b class="ffv p2px">&rsaquo;</b> Job openings for accomodation manager in saudi arabia</p>
									<div class="pt10px">
				<div class="xxxlarge fw6 dif">Accomodation Manager</div>
								
				<br>
				<p class="aj mt7px">To ensure all staff in Housekeeping and Front office departments comply with Hotel Policy regarding uniform and personal hygiene.<br />
<br />
To be aware of the day’s business both in Room Occupancy, Special Requirements and VIP needs.<br />
<br />
Liaise with Reception regarding Room moves, VIP guests, Special Needs and act on any information given.<br />
<br />
Issue keys, room lists, house assistant check lists and cleaning schedules to housekeeping staff at the beginning of shift and collect and check them at end of shift.<br />
<br />
Check all work given to the Room Assistants, Linen Porters and Maintenance throughout the day to ensure standards are being adhered to.<br />
<br />
Excellent Knowledge on of how to inspect properties.<br />
<br />
Regularly Inspect guest rooms, public areas, recreational area for cleanliness, appearance and also to make sure these areas are kept as per the hotels standard.<br />
<br />
Ensure all Maintenance work in Bedrooms, Laundry and Public Areas are rectified prior to releasing rooms back to front desk.<br />
<br />
Ensuring that accommodation is clean, well maintained and attractively presented.<br />
<br />
Ensure that company standards for guest services, décor, and housekeeping services are met or exceeded.<br />
<br />
Ensure Guest’s and Hotel Laundry and Dry Cleaning is dealt to the standard laid down by the hotel management.<br />
<br />
Maintain a par stock levels of stationary, linen and amenity requirements in order to ensure consistency in standards.<br />
<br />
Knowledge of local and company hygiene, health and safety regulations<br />
<br />
Developing and utilising check lists for regular preventative maintenance.<br />
<br />
Developing and utilising check lists for regular cleaning and upkeep.<br />
<br />
Conduct meetings and training sessions as and when required.<br />
<br />
Interview, hire, train, and at times take disciplinary actions on staff members.<br />
<br />
To assist in the development and writing of Housekeeping departmental standards and improved processes.<br />
<br />
To actively train all staff to the standards laid down in the Training Manual and monitor their work performance.<br />
<br />
Approving Duty roste</p>
				
				<table class="w100 formTable bdr0 mt20px">	
				<tr>
				<td class="w195 alpha75 p5px">Experience</td>
				<td class="p5px">5 - 8 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">Hotel / Restaurants /Travel / Airlines</td>
					</tr>
									
									<tr>
					<td class="alpha75 p5px">Qualification</td>
					<td class="p5px">Other Bachelor Degree</td>
					</tr>					
										<tr>
					<td class="alpha75 p5px">Key Skills</td>
					<td class="p5px">
											<span class="bdr dib p2px10px mr5px mt2px">Accomodation Management</span>
												<span class="bdr dib p2px10px mr5px mt2px"> Hospitality Management</span>
												<span class="bdr dib p2px10px mr5px mt2px"> Housekeeping Supervision</span>
												<span class="bdr dib p2px10px mr5px mt2px"> Special Requirements</span>
												<span class="bdr dib p2px10px mr5px mt2px"> Guest Service</span>
												<span class="bdr dib p2px10px mr5px mt2px"> properties Inspection</span>
											</td>
					</tr>
									
				</table>
				</div>
				<br>
				<div class="pt20px">
				<p class="large fw6">About Company</p>
				<div class="mt10px">
				
									<table class="w100 formTable bdr0 mt5px">
											<tr>
						<td class="w195 alpha75 p5px">Contact Person</td>
						<td class="p5px">Dominic Savio</td>
						</tr>					
												<tr>
						<td class="w195 alpha75 p5px">Address</td>
						<td class="p5px">Shop 6/C, Green Lawns Building, Off L J Road, Opp. Al-Saudia Hotel, Near Paradise Cinema, Mahim(W), Mumbai, Maharashtra, India - 400016</td>
						</tr>					
												<tr>
						<td class="w195 alpha75 p5px">Mobile </td>
						<td class="p5px">9930524413 </td>
						</tr>
												<tr>
						<td class="w195 alpha75 p5px">Email ID</td>
						<td class="p5px"><a href="mailto:cv.taexpo@gmail.com"> cv.taexpo@gmail.com </a></td>
						</tr>
										
					</table>
									
				<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="297667">
					<input type="hidden" name="enq_type" value="2"><input type="hidden" name="vacancy_id" value="784835"><input type="hidden" name="subject" value="Applied for Accomodation Manager">
					</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-saudi-arabia.htm" title="Jobs in Saudi Arabia">Saudi Arabia</a> <b class="alpha50 bn small">(8)</b></span>
												<span class="dib p5px10px c2px bdr mr7px mb7px "><a class="dif" href="jobs-in-uae.htm" title="Jobs in United Arab Emirates">United Arab Emirates</a> <b class="alpha50 bn small">(1)</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">(6)</span><a href="jobs-in-cargo-freight-transportation-packaging-shipping-logistic-fid.htm" title="Cargo / Freight / Transportation / Packaging / Shipping/Logistic Jobs">Cargo / Freight / Transportati...</a></p>
										<p class="mb5px "><span class="fr">(2)</span><a href="jobs-in-hotel-restaurants-travel-airlines-fid.htm" title="Hotel / Restaurants /Travel / Airlines Jobs">Hotel / Restaurants /Travel / ...</a></p>
										<p class="mb5px "><span class="fr">(1)</span><a href="jobs-in-manufacturing-production-fid.htm" title="Manufacturing / Production / Quality Jobs">Manufacturing / Production / Q...</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: 'UTFMSFlXMUxRbzhuNVdQYnZnck1Pdz09',data_type: 'RExzRmw1cmRsdlh6YkJlVUZBNnA4UT09'},
	  cache : false,
	  async: true
	  
	}).done(function(resp) {
	  //alert(resp)
	});
	</script>
	";i:1;s:87:"Job openings for accomodation manager in saudi arabia | T. A. Expo & Placement Services";i:2;s:178:"Accomodation Manager Jobs,Accomodation Manager Jobs in ,Accomodation Manager Vacancy in ,Accomodation Manager jobs in Saudi Arabia,Hotel / Restaurants /Travel / Airlines jobs in ";i:3;s:379:"Apply for Accomodation Manager Jobs in  Saudi Arabia - Accomodation Manager Vacancy  in Hotel / Restaurants /Travel / Airlines field with 5 to 8 years Work Experience, Key Skills are Accomodation Management, Hospitality Management, Housekeeping Supervision, Special Requirements, Guest Service, properties Inspection, Hotel / Restaurants /Travel / Airlines jobs in   Saudi Arabia";i:4;s:2765:"
		<script type="application/ld+json">
		{
		  "@context": "http://schema.org",
		  "@type": "JobPosting",
		  "title": "Accomodation Manager",
		  "baseSalary": "",
		  "description": "To ensure all staff in Housekeeping and Front office departments comply with Hotel Policy regarding uniform and personal hygiene.

To be aware of the day’s business both in Room Occupancy, Special Requirements and VIP needs.

Liaise with Reception regarding Room moves, VIP guests, Special Needs and act on any information given.

Issue keys, room lists, house assistant check lists and cleaning schedules to housekeeping staff at the beginning of shift and collect and check them at end of shift.

Check all work given to the Room Assistants, Linen Porters and Maintenance throughout the day to ensure standards are being adhered to.

Excellent Knowledge on of how to inspect properties.

Regularly Inspect guest rooms, public areas, recreational area for cleanliness, appearance and also to make sure these areas are kept as per the hotels standard.

Ensure all Maintenance work in Bedrooms, Laundry and Public Areas are rectified prior to releasing rooms back to front desk.

Ensuring that accommodation is clean, well maintained and attractively presented.

Ensure that company standards for guest services, décor, and housekeeping services are met or exceeded.

Ensure Guest’s and Hotel Laundry and Dry Cleaning is dealt to the standard laid down by the hotel management.

Maintain a par stock levels of stationary, linen and amenity requirements in order to ensure consistency in standards.

Knowledge of local and company hygiene, health and safety regulations

Developing and utilising check lists for regular preventative maintenance.

Developing and utilising check lists for regular cleaning and upkeep.

Conduct meetings and training sessions as and when required.

Interview, hire, train, and at times take disciplinary actions on staff members.

To assist in the development and writing of Housekeeping departmental standards and improved processes.

To actively train all staff to the standards laid down in the Training Manual and monitor their work performance.

Approving Duty roste",
		  "educationRequirements": "Other Bachelor Degree",
		  "experienceRequirements": "5 - 8 Years",
		  "industry": "Hotel / Restaurants /Travel / Airlines",
		  "jobLocation": {
		    "@type": "Place",
		    "address": {
		      "@type": "PostalAddress",
		      "addressLocality": "",
		      "addressRegion": ""
		    }
		  },
		 "qualifications": "Other Bachelor Degree",
		     "skills": "Accomodation Management, Hospitality Management, Housekeeping Supervision, Special Requirements, Guest Service, properties Inspection"
		  }
		</script>
		";i:5;N;}