Job Board

{"map_options":{"center_lat":"63.3359266","center_lng":"-142.9877015","zoom":19,"map_type_id":"ROADMAP","center_by_nearest":false,"fit_bounds":true,"center_circle_fillcolor":"#8CAEF2","center_circle_fillopacity":".5","center_circle_strokecolor":"#8CAEF2","center_circle_strokeopacity":".5","show_center_circle":false,"show_center_marker":false,"center_marker_icon":"https:\/\/turnerstaffing.com\/wp-content\/plugins\/wp-google-map-gold\/assets\/images\/\/default_marker.png","draggable":true,"scroll_wheel":"true","gesture":"auto","marker_default_icon":"https:\/\/turnerstaffing.com\/wp-content\/uploads\/2024\/03\/map-marker-solid.svg","infowindow_setting":"<div class=\"fc-item-box fc-item-no-padding\">\n<div class=\"fc-itemcontent-padding fc-infowindow-content\">\n<div class=\"fc-itemcontent-padding\">\n<div class=\"fc-item-title fc-item-primary-text-color\">{marker_title}<\/div>\n<div class=\"fc-item-content fc-item-body-text-color fc-item-top-space\">\n                {marker_message}\n            <\/div>\n<\/p><\/div>\n<\/p><\/div>\n<\/div>\n","infowindow_geotags_setting":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    {post_title}\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    {post_excerpt}\r\n  <\/p>\r\n  <a href=\"{post_link}\" name=\"{post_title}\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","infowindow_skin":{"name":"kriday","type":"infowindow","sourcecode":"&lt;div class=&quot;fc-item-box fc-item-no-padding&quot;&gt;\r\n    &lt;div class=&quot;fc-itemcontent-padding fc-infowindow-content&quot;&gt;\r\n        &lt;div class=&quot;fc-itemcontent-padding&quot;&gt;\r\n            &lt;div class=&quot;fc-item-title fc-item-primary-text-color&quot;&gt;{marker_title}&lt;\/div&gt;\r\n            &lt;div class=&quot;fc-item-content fc-item-body-text-color fc-item-top-space&quot;&gt;\r\n                {marker_message}\r\n            &lt;\/div&gt;\r\n        &lt;\/div&gt;\r\n    &lt;\/div&gt;\r\n&lt;\/div&gt;"},"infowindow_post_skin":{"name":"kriday","type":"post","sourcecode":"&lt;div class=&quot;tsg-jb-popup-wrapper&quot;&gt;\r\n  &lt;h2 class=&quot;tsg-jb-popup-title&quot;&gt;\r\n    {post_title}\r\n  &lt;\/h2&gt;\r\n  &lt;p class=&quot;tsg-jb-popup-excerpt&quot;&gt;\r\n    {post_excerpt}\r\n  &lt;\/p&gt;\r\n  &lt;a href=&quot;{post_link}&quot; name=&quot;{post_title}&quot; class=&quot;tsg-jb-link&quot;&gt;&lt;button class=&quot;button&quot;&gt;View&lt;\/button&gt;&lt;\/a&gt;\r\n&lt;\/div&gt;"},"infowindow_drop_animation":false,"close_infowindow_on_map_click":false,"default_infowindow_open":false,"infowindow_open_event":"click","listing_infowindow_open_event":"click","is_mobile":false,"infowindow_filter_only":false,"infowindow_click_change_zoom":12,"infowindow_click_change_center":true,"full_screen_control":true,"search_control":true,"search_fields":["{post_title}","{post_content}","{%location_city%}","{%location_state_id%}","{%location_state_name%}"],"zoom_control":true,"map_type_control":false,"street_view_control":false,"locateme_control":false,"mobile_specific":true,"zoom_mobile":5,"draggable_mobile":true,"scroll_wheel_mobile":true,"full_screen_control_position":"TOP_RIGHT","search_control_position":"TOP_LEFT","locateme_control_position":"TOP_LEFT","zoom_control_position":"TOP_LEFT","map_type_control_position":"TOP_RIGHT","map_type_control_style":"HORIZONTAL_BAR","street_view_control_position":"TOP_LEFT","map_control":false,"screens":{"smartphones":{"map_height_mobile":"350","map_zoom_level_mobile":"5"},"ipads":{"map_height_mobile":"350","map_zoom_level_mobile":"5"},"large-screens":{"map_zoom_level_mobile":"5"}},"map_infowindow_customisations":true,"infowindow_width":"100%","infowindow_border_color":"rgba(0, 0, 0, 0.0980392)","infowindow_bg_color":"#fff","show_infowindow_header":false,"min_zoom":"0","max_zoom":"19","zoom_level_after_search":"10","url_filters":true,"doubleclickzoom":false,"current_post_only":false,"search_placeholder":"Search by role or location...","bound_map_after_filter":true,"display_reset_button":true,"map_reset_button_text":"Reset","height":"600"},"places":[{"source":"post","title":"Assay Technician","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Assay Technician\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    We&#8217;re seeking a meticulous and dedicated Sample Preparation Technician to join our night shift team at the a gold mine&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/assay-technician\/\" name=\"Assay Technician\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"We&#8217;re seeking a meticulous and dedicated Sample Preparation Technician to join our night shift team at the a gold mine&hellip;","address":"Tok, AK, USA","location":{"lat":"63.3359266","city":"Tok","state":"AK","country":"United States","lng":"-142.9877015","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/assay-technician\/","zoom":19,"extra_fields":{"post_excerpt":"We&#8217;re seeking a meticulous and dedicated Sample Preparation Technician to join our night shift team at the a gold mine&hellip;","post_content":"<p>We're seeking a meticulous and dedicated Sample Preparation Technician to join our night shift team at the a gold mine near Fairbanks. In this role, you'll be responsible for the crucial task of handling, organizing, and preparing blast hole samples for analysis. Your contributions will directly impact the efficiency and accuracy of our operations, making you an indispensable member of our team.<\/p><p><strong>Key Responsibilities:<\/strong><\/p><ul><li>Handle and organize blast hole samples with precision and care.<\/li><li>Conduct drying, crushing, and pulverizing of samples according to established protocols.<\/li><li>Adhere to safety procedures and protocols at all times.<\/li><li>Maintain cleanliness and organization in the sample preparation area.<\/li><li>Collaborate effectively with team members to ensure smooth workflow.<\/li><li>Document and record sample preparation activities accurately.<\/li><\/ul><p><strong>Qualifications:<\/strong><\/p><ul><li>High school diploma or equivalent.<\/li><li>Valid driver&rsquo;s license.<\/li><li>Previous experience in a similar role is preferred, but not required.<\/li><li>Ability to lift approximately 20 lbs with frequency.<\/li><li>Comfortable working on your feet for extended periods.<\/li><li>Strong attention to detail and organizational skills.<\/li><li>Ability to thrive in a fast-paced, dynamic environment.<\/li><li>Excellent communication and teamwork skills.<\/li><\/ul>","post_title":"Assay Technician","post_link":"https:\/\/turnerstaffing.com\/position\/assay-technician\/","post_featured_image":"","post_categories":"","post_tags":"","%location_country%":"United States","%location_city%":"Tok","%location_state_id%":"AK","%location_city_state%":"Tok, AK","%description%":"<p>We're seeking a meticulous and dedicated Sample Preparation Technician to join our night shift team at the a gold mine near Fairbanks. In this role, you'll be responsible for the crucial task of handling, organizing, and preparing blast hole samples for analysis. Your contributions will directly impact the efficiency and accuracy of our operations, making you an indispensable member of our team.<\/p><p><strong>Key Responsibilities:<\/strong><\/p><ul><li>Handle and organize blast hole samples with precision and care.<\/li><li>Conduct drying, crushing, and pulverizing of samples according to established protocols.<\/li><li>Adhere to safety procedures and protocols at all times.<\/li><li>Maintain cleanliness and organization in the sample preparation area.<\/li><li>Collaborate effectively with team members to ensure smooth workflow.<\/li><li>Document and record sample preparation activities accurately.<\/li><\/ul><p><strong>Qualifications:<\/strong><\/p><ul><li>High school diploma or equivalent.<\/li><li>Valid driver&rsquo;s license.<\/li><li>Previous experience in a similar role is preferred, but not required.<\/li><li>Ability to lift approximately 20 lbs with frequency.<\/li><li>Comfortable working on your feet for extended periods.<\/li><li>Strong attention to detail and organizational skills.<\/li><li>Ability to thrive in a fast-paced, dynamic environment.<\/li><li>Excellent communication and teamwork skills.<\/li><\/ul>","%application_url%":"https:\/\/jobs.crelate.com\/portal\/turnerstaffinggroup\/job\/kfxa14pfa9sdafyfr5ezocqkca","%crelate_id%":"kfxa14pfa9sdafyfr5ezocqkca","%crelate_created_date%":"2025-03-27T23:11:49.63Z","%crelate_updated_date%":"2025-03-28T12:25:29.87Z","%_wpgmp_location_city%":"Tok","%_wpgmp_location_state%":"AK","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Tok, AK, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"63.3359266","%_wpgmp_metabox_longitude%":"-142.9877015","%rank_math_internal_links_processed%":"1"}},"id":2305,"infowindow_disable":false},{"source":"post","title":"Chief Geotechnical Engineer","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Chief Geotechnical Engineer\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Are you a senior geotechnical leader ready to take the helm at one of the most productive open-pit gold mines&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/chief-geotechnical-engineer-2\/\" name=\"Chief Geotechnical Engineer\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Are you a senior geotechnical leader ready to take the helm at one of the most productive open-pit gold mines&hellip;","address":"Round Mountain, NV, USA","location":{"lat":"38.7110428","city":"Round Mountain","state":"NV","country":"United States","lng":"-117.0675843","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/chief-geotechnical-engineer-2\/","zoom":19,"extra_fields":{"post_excerpt":"Are you a senior geotechnical leader ready to take the helm at one of the most productive open-pit gold mines&hellip;","post_content":"<p>Are you a senior geotechnical leader ready to take the helm at one of the most productive open-pit gold mines in the world? Turner Staffing Group is partnering with a major player in the global mining industry to find an accomplished <strong>Chief Geotechnical Engineer<\/strong> for a high-impact role at their flagship open-pit operation in Nevada&mdash;one of the best mining jurisdictions globally.<\/p><p>This is your opportunity to lead geotechnical excellence at a world-class mine that poured its 15 millionth ounce in 2018, is a continuous improvement leader, and plays a vital role in the economic and social wellbeing of Nye County.<\/p><p><strong>About the Opportunity<\/strong><\/p><p>As the <strong>Chief Geotechnical Engineer<\/strong>, you will own all aspects of ground control and geotechnical strategy&mdash;both surface and underground&mdash;ensuring operational safety, geotechnical integrity, and regulatory compliance. You'll work cross-functionally to guide mine design, lead risk assessments, implement QA\/QC protocols, and influence strategic infrastructure development including the major underground \"Phase X\" expansion.<\/p><p>This position offers the chance to leave a lasting mark on one of the most dynamic and forward-thinking mining operations in North America.<\/p><p><strong>What You&rsquo;ll Do<\/strong><\/p><ul><li><p>Lead the development and execution of the Ground Control Management Plan (GCMP)<\/p><\/li><li><p>Drive all ground control functions: hazard management, incident mitigation, mine design, and monitoring systems<\/p><\/li><li><p>Oversee geotechnical design criteria and ensure integration with mine planning<\/p><\/li><li><p>Champion geotechnical risk management systems within the Kinross CRM framework<\/p><\/li><li><p>Support underground infrastructure development and surface\/UG interface planning<\/p><\/li><li><p>Direct QA\/QC programs and manage external geotechnical consultants<\/p><\/li><li><p>Perform advanced geotechnical modeling and analysis using software tools like Rocscience and Map3D<\/p><\/li><li><p>Collaborate with operations, geology, and engineering teams to align goals and drive excellence<\/p><\/li><li><p>Provide technical mentorship to junior engineers and geologists<\/p><\/li><li><p>Coordinate site-wide geotechnical monitoring, inspections, and reporting<\/p><\/li><li><p>Communicate geotechnical strategies and insights clearly and effectively to stakeholders<\/p><\/li><li><p>Uphold strict adherence to safety, environmental, and ethical standards<\/p><\/li><\/ul><p><strong>What You Bring<\/strong><\/p><ul><li><p>Bachelor&rsquo;s degree in Geotechnical Engineering, Geological Engineering, Civil Engineering, or a related field (Master&rsquo;s preferred)<\/p><\/li><li><p>8&ndash;12 years of geotechnical experience in mining operations, with both underground and surface exposure<\/p><\/li><li><p>Deep knowledge of ground control, rock mass behavior, geotechnical instrumentation, and mine safety protocols<\/p><\/li><li><p>Expertise in geotechnical design, hazard analysis, and risk mitigation<\/p><\/li><li><p>Familiarity with Vulcan, Deswik, Rocscience, Map3D, and other modeling tools<\/p><\/li><li><p>Outstanding leadership, communication, and cross-functional collaboration skills<\/p><\/li><li><p>Strong mentoring ability and experience leading geotechnical teams<\/p><\/li><li><p>Valid driver&rsquo;s license and authorization to work in the U.S.<\/p><\/li><\/ul><p><strong>Why You Should Apply<\/strong><\/p><ul><li><p>Be the geotechnical authority at a globally recognized mine<\/p><\/li><li><p>Shape critical infrastructure and lead high-impact engineering programs<\/p><\/li><li><p>Join a values-driven culture committed to continuous improvement, safety, and community investment<\/p><\/li><li><p>Competitive compensation and benefits package<\/p><\/li><li><p>Enjoy a high quality of life in a location with wide-open spaces and a tight-knit community<\/p><\/li><\/ul>","post_title":"Chief Geotechnical Engineer","post_link":"https:\/\/turnerstaffing.com\/position\/chief-geotechnical-engineer-2\/","post_featured_image":"","post_categories":"","post_tags":"","%location_country%":"United States","%location_city%":"Round Mountain","%location_state_id%":"NV","%location_city_state%":"Round Mountain, NV","%description%":"<p>Are you a senior geotechnical leader ready to take the helm at one of the most productive open-pit gold mines in the world? Turner Staffing Group is partnering with a major player in the global mining industry to find an accomplished <strong>Chief Geotechnical Engineer<\/strong> for a high-impact role at their flagship open-pit operation in Nevada&mdash;one of the best mining jurisdictions globally.<\/p><p>This is your opportunity to lead geotechnical excellence at a world-class mine that poured its 15 millionth ounce in 2018, is a continuous improvement leader, and plays a vital role in the economic and social wellbeing of Nye County.<\/p><p><strong>About the Opportunity<\/strong><\/p><p>As the <strong>Chief Geotechnical Engineer<\/strong>, you will own all aspects of ground control and geotechnical strategy&mdash;both surface and underground&mdash;ensuring operational safety, geotechnical integrity, and regulatory compliance. You'll work cross-functionally to guide mine design, lead risk assessments, implement QA\/QC protocols, and influence strategic infrastructure development including the major underground \"Phase X\" expansion.<\/p><p>This position offers the chance to leave a lasting mark on one of the most dynamic and forward-thinking mining operations in North America.<\/p><p><strong>What You&rsquo;ll Do<\/strong><\/p><ul><li><p>Lead the development and execution of the Ground Control Management Plan (GCMP)<\/p><\/li><li><p>Drive all ground control functions: hazard management, incident mitigation, mine design, and monitoring systems<\/p><\/li><li><p>Oversee geotechnical design criteria and ensure integration with mine planning<\/p><\/li><li><p>Champion geotechnical risk management systems within the Kinross CRM framework<\/p><\/li><li><p>Support underground infrastructure development and surface\/UG interface planning<\/p><\/li><li><p>Direct QA\/QC programs and manage external geotechnical consultants<\/p><\/li><li><p>Perform advanced geotechnical modeling and analysis using software tools like Rocscience and Map3D<\/p><\/li><li><p>Collaborate with operations, geology, and engineering teams to align goals and drive excellence<\/p><\/li><li><p>Provide technical mentorship to junior engineers and geologists<\/p><\/li><li><p>Coordinate site-wide geotechnical monitoring, inspections, and reporting<\/p><\/li><li><p>Communicate geotechnical strategies and insights clearly and effectively to stakeholders<\/p><\/li><li><p>Uphold strict adherence to safety, environmental, and ethical standards<\/p><\/li><\/ul><p><strong>What You Bring<\/strong><\/p><ul><li><p>Bachelor&rsquo;s degree in Geotechnical Engineering, Geological Engineering, Civil Engineering, or a related field (Master&rsquo;s preferred)<\/p><\/li><li><p>8&ndash;12 years of geotechnical experience in mining operations, with both underground and surface exposure<\/p><\/li><li><p>Deep knowledge of ground control, rock mass behavior, geotechnical instrumentation, and mine safety protocols<\/p><\/li><li><p>Expertise in geotechnical design, hazard analysis, and risk mitigation<\/p><\/li><li><p>Familiarity with Vulcan, Deswik, Rocscience, Map3D, and other modeling tools<\/p><\/li><li><p>Outstanding leadership, communication, and cross-functional collaboration skills<\/p><\/li><li><p>Strong mentoring ability and experience leading geotechnical teams<\/p><\/li><li><p>Valid driver&rsquo;s license and authorization to work in the U.S.<\/p><\/li><\/ul><p><strong>Why You Should Apply<\/strong><\/p><ul><li><p>Be the geotechnical authority at a globally recognized mine<\/p><\/li><li><p>Shape critical infrastructure and lead high-impact engineering programs<\/p><\/li><li><p>Join a values-driven culture committed to continuous improvement, safety, and community investment<\/p><\/li><li><p>Competitive compensation and benefits package<\/p><\/li><li><p>Enjoy a high quality of life in a location with wide-open spaces and a tight-knit community<\/p><\/li><\/ul>","%application_url%":"https:\/\/jobs.crelate.com\/portal\/turnerstaffinggroup\/job\/tu8s5ajx6r5kosk7i9hbsbntmo","%crelate_id%":"tu8s5ajx6r5kosk7i9hbsbntmo","%crelate_created_date%":"2025-03-28T13:17:50.9Z","%crelate_updated_date%":"2025-03-28T23:11:43.59Z","%_wpgmp_location_city%":"Round Mountain","%_wpgmp_location_state%":"NV","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Round Mountain, NV, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"38.7110428","%_wpgmp_metabox_longitude%":"-117.0675843","%rank_math_internal_links_processed%":"1"}},"id":2304,"infowindow_disable":false},{"source":"post","title":"Chief Geotechnical Engineer","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Chief Geotechnical Engineer\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Are you a senior geotechnical leader ready to take the helm at one of the most productive open-pit gold mines&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/chief-geotechnical-engineer\/\" name=\"Chief Geotechnical Engineer\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Are you a senior geotechnical leader ready to take the helm at one of the most productive open-pit gold mines&hellip;","address":"Round Mountain, NV, USA","location":{"lat":"38.7110428","city":"Round Mountain","state":"NV","country":"United States","lng":"-117.0675843","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/chief-geotechnical-engineer\/","zoom":19,"extra_fields":{"post_excerpt":"Are you a senior geotechnical leader ready to take the helm at one of the most productive open-pit gold mines&hellip;","post_content":"<p>Are you a senior geotechnical leader ready to take the helm at one of the most productive open-pit gold mines in the world? Turner Staffing Group is partnering with a major player in the global mining industry to find an accomplished&nbsp;<strong>Chief Geotechnical Engineer<\/strong>&nbsp;for a high-impact role at their flagship open-pit operation in Nevada\u2014one of the best mining jurisdictions globally.<\/p>\n<p>This is your opportunity to lead geotechnical excellence at a world-class mine that poured its 15 millionth ounce in 2018, is a continuous improvement leader, and plays a vital role in the economic and social wellbeing of Nye County.<\/p>\n<p><strong>About the Opportunity<\/strong><\/p>\n<p>As the&nbsp;<strong>Chief Geotechnical Engineer<\/strong>, you will own all aspects of ground control and geotechnical strategy\u2014both surface and underground\u2014ensuring operational safety, geotechnical integrity, and regulatory compliance. You'll work cross-functionally to guide mine design, lead risk assessments, implement QA\/QC protocols, and influence strategic infrastructure development including the major underground \"Phase X\" expansion.<\/p>\n<p>This position offers the chance to leave a lasting mark on one of the most dynamic and forward-thinking mining operations in North America.<\/p>\n<p><strong>What You\u2019ll Do<\/strong><\/p>\n<ul><li>Lead the development and execution of the Ground Control Management Plan (GCMP)<\/li><li>Drive all ground control functions: hazard management, incident mitigation, mine design, and monitoring systems<\/li><li>Oversee geotechnical design criteria and ensure integration with mine planning<\/li><li>Champion geotechnical risk management systems within the Kinross CRM framework<\/li><li>Support underground infrastructure development and surface\/UG interface planning<\/li><li>Direct QA\/QC programs and manage external geotechnical consultants<\/li><li>Perform advanced geotechnical modeling and analysis using software tools like Rocscience and Map3D<\/li><li>Collaborate with operations, geology, and engineering teams to align goals and drive excellence<\/li><li>Provide technical mentorship to junior engineers and geologists<\/li><li>Coordinate site-wide geotechnical monitoring, inspections, and reporting<\/li><li>Communicate geotechnical strategies and insights clearly and effectively to stakeholders<\/li><li>Uphold strict adherence to safety, environmental, and ethical standards<\/li><\/ul>\n<p><strong>What You Bring<\/strong><\/p>\n<ul><li>Bachelor\u2019s degree in Geotechnical Engineering, Geological Engineering, Civil Engineering, or a related field (Master\u2019s preferred)<\/li><li>8\u201312 years of geotechnical experience in mining operations, with both underground and surface exposure<\/li><li>Deep knowledge of ground control, rock mass behavior, geotechnical instrumentation, and mine safety protocols<\/li><li>Expertise in geotechnical design, hazard analysis, and risk mitigation<\/li><li>Familiarity with Vulcan, Deswik, Rocscience, Map3D, and other modeling tools<\/li><li>Outstanding leadership, communication, and cross-functional collaboration skills<\/li><li>Strong mentoring ability and experience leading geotechnical teams<\/li><li>Valid driver\u2019s license and authorization to work in the U.S.<\/li><\/ul>\n<p><strong>Why You Should Apply<\/strong><\/p>\n<ul><li>Be the geotechnical authority at a globally recognized mine<\/li><li>Shape critical infrastructure and lead high-impact engineering programs<\/li><li>Join a values-driven culture committed to continuous improvement, safety, and community investment<\/li><li>Competitive compensation and benefits package<\/li><li>Enjoy a high quality of life in a location with wide-open spaces and a tight-knit community<\/li><\/ul>","post_title":"Chief Geotechnical Engineer","post_link":"https:\/\/turnerstaffing.com\/position\/chief-geotechnical-engineer\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"","%location_country%":"United States","%location_city%":"Round Mountain","%location_state_id%":"NV","%location_state_name%":"Nevada","%location_city_state%":"Round Mountain, NV","%education%":"","%department%":"","%description%":"<p>Are you a senior geotechnical leader ready to take the helm at one of the most productive open-pit gold mines in the world? Turner Staffing Group is partnering with a major player in the global mining industry to find an accomplished&nbsp;<strong>Chief Geotechnical Engineer<\/strong>&nbsp;for a high-impact role at their flagship open-pit operation in Nevada\u2014one of the best mining jurisdictions globally.<\/p>\n<p>This is your opportunity to lead geotechnical excellence at a world-class mine that poured its 15 millionth ounce in 2018, is a continuous improvement leader, and plays a vital role in the economic and social wellbeing of Nye County.<\/p>\n<p><strong>About the Opportunity<\/strong><\/p>\n<p>As the&nbsp;<strong>Chief Geotechnical Engineer<\/strong>, you will own all aspects of ground control and geotechnical strategy\u2014both surface and underground\u2014ensuring operational safety, geotechnical integrity, and regulatory compliance. You'll work cross-functionally to guide mine design, lead risk assessments, implement QA\/QC protocols, and influence strategic infrastructure development including the major underground \"Phase X\" expansion.<\/p>\n<p>This position offers the chance to leave a lasting mark on one of the most dynamic and forward-thinking mining operations in North America.<\/p>\n<p><strong>What You\u2019ll Do<\/strong><\/p>\n<ul><li>Lead the development and execution of the Ground Control Management Plan (GCMP)<\/li><li>Drive all ground control functions: hazard management, incident mitigation, mine design, and monitoring systems<\/li><li>Oversee geotechnical design criteria and ensure integration with mine planning<\/li><li>Champion geotechnical risk management systems within the Kinross CRM framework<\/li><li>Support underground infrastructure development and surface\/UG interface planning<\/li><li>Direct QA\/QC programs and manage external geotechnical consultants<\/li><li>Perform advanced geotechnical modeling and analysis using software tools like Rocscience and Map3D<\/li><li>Collaborate with operations, geology, and engineering teams to align goals and drive excellence<\/li><li>Provide technical mentorship to junior engineers and geologists<\/li><li>Coordinate site-wide geotechnical monitoring, inspections, and reporting<\/li><li>Communicate geotechnical strategies and insights clearly and effectively to stakeholders<\/li><li>Uphold strict adherence to safety, environmental, and ethical standards<\/li><\/ul>\n<p><strong>What You Bring<\/strong><\/p>\n<ul><li>Bachelor\u2019s degree in Geotechnical Engineering, Geological Engineering, Civil Engineering, or a related field (Master\u2019s preferred)<\/li><li>8\u201312 years of geotechnical experience in mining operations, with both underground and surface exposure<\/li><li>Deep knowledge of ground control, rock mass behavior, geotechnical instrumentation, and mine safety protocols<\/li><li>Expertise in geotechnical design, hazard analysis, and risk mitigation<\/li><li>Familiarity with Vulcan, Deswik, Rocscience, Map3D, and other modeling tools<\/li><li>Outstanding leadership, communication, and cross-functional collaboration skills<\/li><li>Strong mentoring ability and experience leading geotechnical teams<\/li><li>Valid driver\u2019s license and authorization to work in the U.S.<\/li><\/ul>\n<p><strong>Why You Should Apply<\/strong><\/p>\n<ul><li>Be the geotechnical authority at a globally recognized mine<\/li><li>Shape critical infrastructure and lead high-impact engineering programs<\/li><li>Join a values-driven culture committed to continuous improvement, safety, and community investment<\/li><li>Competitive compensation and benefits package<\/li><li>Enjoy a high quality of life in a location with wide-open spaces and a tight-knit community<\/li><\/ul>","%category%":"Operations","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/9ce993f3e057-chief-geotechnical-engineer","%breezy_id%":"9ce993f3e057","%breezy_friendly_id%":"9ce993f3e057-chief-geotechnical-engineer","%breezy_created_date%":"2025-03-28T13:26:03.206Z","%breezy_updated_date%":"2025-03-28T13:26:32.122Z","%_wpgmp_location_city%":"Round Mountain","%_wpgmp_location_state%":"NV","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Round Mountain, NV, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"38.7110428","%_wpgmp_metabox_longitude%":"-117.0675843","%rank_math_internal_links_processed%":"1"}},"id":2303,"infowindow_disable":false},{"source":"post","title":"Construction Manager","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Construction Manager\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    We are seeking a highly motivated and experienced, onsite, project-based Construction Project Manager to oversee the development and execution of&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/construction-manager\/\" name=\"Construction Manager\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"We are seeking a highly motivated and experienced, onsite, project-based Construction Project Manager to oversee the development and execution of&hellip;","address":"Ridgeway, SC, USA","location":{"lat":"34.307647","city":"Ridgeway","state":"SC","country":"United States","lng":"-80.9603643","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/construction-manager\/","zoom":19,"extra_fields":{"post_excerpt":"We are seeking a highly motivated and experienced, onsite, project-based Construction Project Manager to oversee the development and execution of&hellip;","post_content":"<p><span style=\"color:black\">We are seeking a highly motivated and experienced, onsite, project-based Construction Project Manager to oversee the development and execution of a significant (approximately 24 month) project. The ideal candidate will have a strong background in construction management, with expertise in coordinating all phases of project development from pre-construction to commissioning.<\/span><\/p><p><span style=\"color:black\">Key Responsibilities:<\/span><\/p><ol><li>Project Planning and Scheduling: Develop and maintain a comprehensive project development schedule based on the pre-construction schematic design. Coordinate with design teams, subcontractors, and stakeholders to ensure project milestones are met.<\/li><li>Constructability Assessment: Facilitate three design reviews throughout 2024 to assess constructability and identify potential challenges. Collaborate with the design team to implement feedback and adjustments as needed.<\/li><li>Procurement and Contractor Management: Lead the procurement process for construction services, including conducting a contractor pre-bid walk in fall 2024. Solicit feedback from potential contractors on design, construction methodology, sequencing, and schedule. Incorporate contractor input into the pre-final design stage (90% completion).<\/li><li>Project Execution: Oversee construction activities in alignment with the finalized design and schedule. Coordinate with subcontractors, suppliers, and onsite personnel to ensure efficient project delivery. Monitor progress, address issues, and implement solutions to keep the project on track.<\/li><li>Quality Control and Assurance: Implement quality control measures to uphold project standards and specifications. Conduct regular inspections and audits to ensure compliance with regulatory requirements and client expectations.<\/li><li>Risk Management: Identify potential risks and develop mitigation strategies to minimize disruptions and delays. Proactively address issues related to budget, schedule, and scope changes to maintain project integrity.<\/li><li>Stakeholder Communication: Serve as the primary point of contact for project stakeholders, including The Company and other relevant agencies. Provide regular updates on project status, milestones, and key deliverables. Address any concerns or inquiries in a timely and professional manner.<\/li><\/ol><p><span style=\"color:black\">Qualifications:<\/span><\/p><ul><li>Bachelor's degree in Construction Management, Civil Engineering, or related field (Master's degree preferred).<\/li><li>Experience in construction project management, with a proven track record of successfully delivering complex projects on time and within budget.<\/li><li>Proficiency in project management software (e.g., Primavera P6, Procore) and Microsoft Office Suite.<\/li><li>Strong leadership skills with the ability to effectively manage multidisciplinary teams and foster collaboration.<\/li><li>Excellent communication and negotiation skills, with the ability to interact confidently with clients, contractors, and stakeholders.<\/li><li>Knowledge of construction regulations, building codes, and industry best practices.<\/li><li>Authorized to work in the US without work visa sponsorship<\/li><\/ul><p><span style=\"color:black\">Benefits:<\/span><\/p><ul><li>Competitive salary commensurate with experience<\/li><li>Comprehensive health benefits package<\/li><li>Retirement savings plan<\/li><li>Professional development opportunities<\/li><li>Dynamic and collaborative work environment<\/li><\/ul><p>&nbsp;<\/p>","post_title":"Construction Manager","post_link":"https:\/\/turnerstaffing.com\/position\/construction-manager\/","post_featured_image":"","post_categories":"","post_tags":"","%location_country%":"United States","%location_city%":"Ridgeway","%location_state_id%":"SC","%location_city_state%":"Ridgeway, SC","%description%":"<p><span style=\"color:black;\">We are seeking a highly motivated and experienced, onsite, project-based Construction Project Manager to oversee the development and execution of a significant (approximately 24 month) project. The ideal candidate will have a strong background in construction management, with expertise in coordinating all phases of project development from pre-construction to commissioning.<\/span><\/p><p><span style=\"color:black;\">Key Responsibilities:<\/span><\/p><ol><li>Project Planning and Scheduling: Develop and maintain a comprehensive project development schedule based on the pre-construction schematic design. Coordinate with design teams, subcontractors, and stakeholders to ensure project milestones are met.<\/li><li>Constructability Assessment: Facilitate three design reviews throughout 2024 to assess constructability and identify potential challenges. Collaborate with the design team to implement feedback and adjustments as needed.<\/li><li>Procurement and Contractor Management: Lead the procurement process for construction services, including conducting a contractor pre-bid walk in fall 2024. Solicit feedback from potential contractors on design, construction methodology, sequencing, and schedule. Incorporate contractor input into the pre-final design stage (90% completion).<\/li><li>Project Execution: Oversee construction activities in alignment with the finalized design and schedule. Coordinate with subcontractors, suppliers, and onsite personnel to ensure efficient project delivery. Monitor progress, address issues, and implement solutions to keep the project on track.<\/li><li>Quality Control and Assurance: Implement quality control measures to uphold project standards and specifications. Conduct regular inspections and audits to ensure compliance with regulatory requirements and client expectations.<\/li><li>Risk Management: Identify potential risks and develop mitigation strategies to minimize disruptions and delays. Proactively address issues related to budget, schedule, and scope changes to maintain project integrity.<\/li><li>Stakeholder Communication: Serve as the primary point of contact for project stakeholders, including The Company and other relevant agencies. Provide regular updates on project status, milestones, and key deliverables. Address any concerns or inquiries in a timely and professional manner.<\/li><\/ol><p><span style=\"color:black;\">Qualifications:<\/span><\/p><ul><li>Bachelor's degree in Construction Management, Civil Engineering, or related field (Master's degree preferred).<\/li><li>Experience in construction project management, with a proven track record of successfully delivering complex projects on time and within budget.<\/li><li>Proficiency in project management software (e.g., Primavera P6, Procore) and Microsoft Office Suite.<\/li><li>Strong leadership skills with the ability to effectively manage multidisciplinary teams and foster collaboration.<\/li><li>Excellent communication and negotiation skills, with the ability to interact confidently with clients, contractors, and stakeholders.<\/li><li>Knowledge of construction regulations, building codes, and industry best practices.<\/li><li>Authorized to work in the US without work visa sponsorship<\/li><\/ul><p><span style=\"color:black;\">Benefits:<\/span><\/p><ul><li>Competitive salary commensurate with experience<\/li><li>Comprehensive health benefits package<\/li><li>Retirement savings plan<\/li><li>Professional development opportunities<\/li><li>Dynamic and collaborative work environment<\/li><\/ul><p>&nbsp;<\/p>","%application_url%":"https:\/\/jobs.crelate.com\/portal\/turnerstaffinggroup\/job\/hkfythrxtxutj636531gokqacc","%crelate_id%":"hkfythrxtxutj636531gokqacc","%crelate_created_date%":"2025-03-26T18:50:59.65Z","%crelate_updated_date%":"2025-03-27T13:38:20.26Z","%_wpgmp_location_city%":"Ridgeway","%_wpgmp_location_state%":"SC","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Ridgeway, SC, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"34.307647","%_wpgmp_metabox_longitude%":"-80.9603643","%rank_math_internal_links_processed%":"1"}},"id":2301,"infowindow_disable":false},{"source":"post","title":"Contracts Specialist","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Contracts Specialist\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Turner Staffing Group is currently seeking a Contracts Specialist to join our team to work at our client&#8217;s office near&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/contracts-specialist-3\/\" name=\"Contracts Specialist\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Turner Staffing Group is currently seeking a Contracts Specialist to join our team to work at our client&#8217;s office near&hellip;","address":"Elko, NV, USA","location":{"lat":"40.8436459","city":"Elko","state":"NV","country":"United States","lng":"-115.7526187","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/contracts-specialist-3\/","zoom":19,"extra_fields":{"post_excerpt":"Turner Staffing Group is currently seeking a Contracts Specialist to join our team to work at our client&#8217;s office near&hellip;","post_content":"<p>Turner Staffing Group is currently seeking a Contracts Specialist to join our team to work at our client's office near Elko, NV. This onsite, project-based position will support the tendering and awarding of contracts for goods and services related to near-mine or in-mine facilities, adhering to established policies and procedures. This role will involve working as part of a team, with indirect supervision, and performing a wide range of contract acquisition and administration tasks.<\/p><p><strong>Key Responsibilities:<\/strong><\/p><ul><li>Responsible for delivering contracts that meet the operational and commercial needs of user areas, ensuring the timely supply of goods and services.<\/li><li>Manage the tender process, including developing contract documentation, coordinating information for evaluating proposals, and supporting the selection of service providers.<\/li><li>Prepare letters, reports, and other documents to support contractual actions or recommendations.<\/li><li>Maintain and update a contracts register for the end-user group.<\/li><li>Support the continuous improvement of sourcing strategies, policies, and guidelines related to service categories and contracts.<\/li><li>Ensure professional service to user departments, including bid preparation, negotiations with suppliers, and management of contract execution and closeouts.<\/li><li>Analyze solicitation responses, including price reasonableness, competition, compliance, and requirements fulfillment.<\/li><li>Act as a central point of contact for assigned procurements and manage contractor\/vendor relationships.<\/li><li>Monitor contractor compliance with contractual obligations, including cost and schedule management.<\/li><li>Acquire services that meet operational requirements while optimizing cost, execution time, and quality.<\/li><li>Support program integration and the implementation of best practices in project controls and governance.<\/li><li>Resolve queries from operations, providing information on policies and work products, and referring to others for policy interpretation when necessary.<\/li><li>Utilize sourcing and procurement systems approved for contract execution and management.<\/li><li>Handle small project workstreams, ensuring adherence to project management methodologies and permitting processes.<\/li><li>Follow HS&amp;E policies and procedures to mitigate environmental and workplace risks.<\/li><li>Continue professional development by participating in training and gaining relevant accreditation.<\/li><li>Be available for after-hour emergency procurement activities during scheduled \"on-call\" rotations.<\/li><\/ul><p><strong>Qualifications:<\/strong><\/p><p><strong>Education:<\/strong><\/p><ul><li>Bachelor&rsquo;s degree in Business, Supply Chain, Accounting, or a related field, or equivalent experience.<\/li><\/ul><p><strong>Experience:<\/strong><\/p><ul><li>Minimum of 5 years of directly related contracting and procurement experience or an equivalent combination of training and experience.<\/li><li>Experience in developing RFQs and RFPs.<\/li><li>Expertise in negotiating contractual conflict resolution.<\/li><li>Proficiency with Ariba or similar sourcing and contract management systems.<\/li><li>Strong skills in Microsoft Office Suite (Word, Excel, PowerPoint, Visio, Outlook).<\/li><li>Authorized to work in the US without work visa sponsorship.<\/li><\/ul>","post_title":"Contracts Specialist","post_link":"https:\/\/turnerstaffing.com\/position\/contracts-specialist-3\/","post_featured_image":"","post_categories":"","post_tags":"","%location_country%":"United States","%location_city%":"Elko","%location_state_id%":"NV","%location_city_state%":"Elko, NV","%description%":"<p>Turner Staffing Group is currently seeking a Contracts Specialist to join our team to work at our client's office near Elko, NV. This onsite, project-based position will support the tendering and awarding of contracts for goods and services related to near-mine or in-mine facilities, adhering to established policies and procedures. This role will involve working as part of a team, with indirect supervision, and performing a wide range of contract acquisition and administration tasks.<\/p><p><strong>Key Responsibilities:<\/strong><\/p><ul><li>Responsible for delivering contracts that meet the operational and commercial needs of user areas, ensuring the timely supply of goods and services.<\/li><li>Manage the tender process, including developing contract documentation, coordinating information for evaluating proposals, and supporting the selection of service providers.<\/li><li>Prepare letters, reports, and other documents to support contractual actions or recommendations.<\/li><li>Maintain and update a contracts register for the end-user group.<\/li><li>Support the continuous improvement of sourcing strategies, policies, and guidelines related to service categories and contracts.<\/li><li>Ensure professional service to user departments, including bid preparation, negotiations with suppliers, and management of contract execution and closeouts.<\/li><li>Analyze solicitation responses, including price reasonableness, competition, compliance, and requirements fulfillment.<\/li><li>Act as a central point of contact for assigned procurements and manage contractor\/vendor relationships.<\/li><li>Monitor contractor compliance with contractual obligations, including cost and schedule management.<\/li><li>Acquire services that meet operational requirements while optimizing cost, execution time, and quality.<\/li><li>Support program integration and the implementation of best practices in project controls and governance.<\/li><li>Resolve queries from operations, providing information on policies and work products, and referring to others for policy interpretation when necessary.<\/li><li>Utilize sourcing and procurement systems approved for contract execution and management.<\/li><li>Handle small project workstreams, ensuring adherence to project management methodologies and permitting processes.<\/li><li>Follow HS&amp;E policies and procedures to mitigate environmental and workplace risks.<\/li><li>Continue professional development by participating in training and gaining relevant accreditation.<\/li><li>Be available for after-hour emergency procurement activities during scheduled \"on-call\" rotations.<\/li><\/ul><p><strong>Qualifications:<\/strong><\/p><p><strong>Education:<\/strong><\/p><ul><li>Bachelor&rsquo;s degree in Business, Supply Chain, Accounting, or a related field, or equivalent experience.<\/li><\/ul><p><strong>Experience:<\/strong><\/p><ul><li>Minimum of 5 years of directly related contracting and procurement experience or an equivalent combination of training and experience.<\/li><li>Experience in developing RFQs and RFPs.<\/li><li>Expertise in negotiating contractual conflict resolution.<\/li><li>Proficiency with Ariba or similar sourcing and contract management systems.<\/li><li>Strong skills in Microsoft Office Suite (Word, Excel, PowerPoint, Visio, Outlook).<\/li><li>Authorized to work in the US without work visa sponsorship.<\/li><\/ul>","%application_url%":"https:\/\/jobs.crelate.com\/portal\/turnerstaffinggroup\/job\/oec1gqrb3pxmpf7otg59s37ecw","%crelate_id%":"oec1gqrb3pxmpf7otg59s37ecw","%crelate_created_date%":"2025-03-19T13:03:39.22Z","%crelate_updated_date%":"2025-03-28T15:43:46.79Z","%_wpgmp_location_city%":"Elko","%_wpgmp_location_state%":"NV","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Elko, NV, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"40.8436459","%_wpgmp_metabox_longitude%":"-115.7526187","%rank_math_internal_links_processed%":"1"}},"id":2299,"infowindow_disable":false},{"source":"post","title":"Electrician","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Electrician\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    POSITION SUMMARY: A strong team member will perform duties including but not limited to electrician and all aspects of mechanical&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/electrician-2\/\" name=\"Electrician\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"POSITION SUMMARY: A strong team member will perform duties including but not limited to electrician and all aspects of mechanical&hellip;","address":"New Braunfels, TX, USA","location":{"lat":"29.702566","city":"New Braunfels","state":"TX","country":"United States","lng":"-98.1240635","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/electrician-2\/","zoom":19,"extra_fields":{"post_excerpt":"POSITION SUMMARY: A strong team member will perform duties including but not limited to electrician and all aspects of mechanical&hellip;","post_content":"<p><strong>POSITION SUMMARY: <\/strong><\/p>\n<p>A strong team member will perform duties including but not limited to electrician and all aspects of mechanical maintenance. Team member will be able to troubleshoot issues to ensure all electrical and mechanical components are in good working order throughout the plant.<\/p>\n<p><\/p>\n<p><strong>RESPONSIBILITIES &amp; EXPECTATIONS:<\/strong><\/p>\n<p><strong>Electrical<\/strong><\/p>\n<ul><li>Perform basic electrical calculations.<\/li><li>Perform tasks with all electrical test equipment (voltage meters, meggers, current generators, loop calibrators, etc.)<\/li><li>Fabricate and install conduit.<\/li><li>Troubleshoot and maintain motor control circuits.<\/li><li>Troubleshoot and maintain automation equipment and associated instrumentations.<\/li><li>Troubleshoot and maintain variable speed drives.<\/li><li>Proficient in working with low to medium voltage power (4,160V) and associated systems.<\/li><li>Willing to perform any other assigned tasks not specifically indicated.<\/li><\/ul>\n<p><\/p>\n<p><strong>Maintenance<\/strong><\/p>\n<ul><li>Understand the installation and maintenance of all types of bearings.<\/li><li>Perform shaft alignments using precision tools.<\/li><li>Must be able to disassemble and rebuild all types of crushing, screening, and conveying equipment.<\/li><li>Perform preventive maintenance checks and report findings verbally and in writing.<\/li><li>Perform preventative maintenance tasks on the mechanical systems including inspection and lubrication.&nbsp;<\/li><li>Troubleshoot and perform repairs to hydraulic systems and pneumatics systems.<\/li><li>Troubleshoot and perform repairs on various environmental mitigation equipment.<\/li><li>Perform some mechanical work.<\/li><li>Willing to perform any other assigned tasks not specifically indicated.<\/li><\/ul>\n<p><\/p>\n<p><strong>Training<\/strong><\/p>\n<ul><li>Operate small mobile equipment.<\/li><li>Willing to train on any new equipment installations.<\/li><li>Willing to perform any other assigned tasks not specifically indicated.<\/li><\/ul>\n<p><br><strong>Safety <\/strong><\/p>\n<ul><li>Must be well versed on all aspects of safety.<\/li><li>Comply with company, state, and governmental health and safety regulations at all times.<\/li><li>Complete and document Workplace Inspections in a timely manner.<\/li><li>Ensure maintenance tools are kept in good condition, repaired or replaced when necessary.<\/li><\/ul>\n<p><\/p>\n<p><strong>ATTRIBUTES:<\/strong><\/p>\n<ul><li>Good decision-making skills regarding safety<\/li><li>Knowledgeable of current environmental regulations and practices as they relate to the lime industry.<\/li><li><strong>Electrical<\/strong><ul><li>Perform basic electrical calculations.<\/li><li>Perform tasks with all electrical test equipment (voltage meters, meggers, current generators, loop calibrators, etc.)<\/li><li>Fabricate and install conduit.<\/li><li>Troubleshoot and maintain motor control circuits.<\/li><li>Troubleshoot and maintain automation equipment and associated instrumentations.<\/li><li>Troubleshoot and maintain variable speed drives.<\/li><li>Proficient in working with low to medium voltage power (4,160V) and associated systems.<\/li><li>Willing to perform any other assigned tasks not specifically indicated.<\/li><\/ul><\/li><\/ul>\n<p><\/p>\n<p><strong>Maintenance<\/strong><\/p>\n<ul><li>Understand the installation and maintenance of all types of bearings.<\/li><li>Perform shaft alignments using precision tools.<\/li><li>Must be able to disassemble and rebuild all types of crushing, screening, and conveying equipment.<\/li><li>Perform preventive maintenance checks and report findings verbally and in writing.<\/li><li>Perform preventative maintenance tasks on the mechanical systems including inspection and lubrication.&nbsp;<\/li><li>Troubleshoot and perform repairs to hydraulic systems and pneumatics systems.<\/li><li>Troubleshoot and perform repairs on various environmental mitigation equipment.<\/li><li>Perform some mechanical work.<\/li><li>Willing to perform any other assigned tasks not specifically indicated.<\/li><\/ul>\n<p><\/p>\n<p><strong>Training<\/strong><\/p>\n<ul><li>Operate small mobile equipment.<\/li><li>Willing to train on any new equipment installations.<\/li><li>Willing to perform any other assigned tasks not specifically indicated.<\/li><\/ul>\n<p><\/p>\n<p><strong>Safety <\/strong><\/p>\n<ul><li>Must be well versed on all aspects of safety.<\/li><li>Comply with company, state, and governmental health and safety regulations at all times.<\/li><li>Complete and document Workplace Inspections in a timely manner.<\/li><li>Ensure maintenance tools are kept in good condition, repaired or replaced when necessary.<\/li><\/ul>\n<p><br><\/p>\n\n\n<p><strong>PHYSICAL DEMANDS INCLUDE, BUT ARE NOT LIMITED TO: <\/strong><\/p>\n<p><\/p>\n<p><strong>ATTRIBUTES:<\/strong><\/p>\n<ul><li>&nbsp;3+ years or the ability to demonstrate electrical and instrumentation experience including some wiring and motor installation, and equipment troubleshooting<\/li><li>&nbsp;Completion of an apprenticeship program, technical program, or equivalent experience in industrial background.<\/li><li>High School Diploma or GED Equivalent.<\/li><li>Tolerate working outside in severe weather conditions as well as exposure to industrial high temperature, noise and dust.<\/li><li>Access all areas within a site which could include heights of 120 feet, confined spaces, climbing ladders or stairs, and accessing tunnels.<\/li><li>Able to lift over 50 pounds.<\/li><li>Workday or shift work and also be able to take call out as needed. Work as needed if there are issues with equipment in the plant after normal hours or weekends.<\/li><li>Good decision-making skills regarding safety<\/li><li>Knowledgeable of current environmental regulations and practices as they relate to the lime industry.<\/li><li>Proficient knowledge of E&amp;I, hydraulics and pneumatics to assist in troubleshooting equipment failures.<\/li><li>Industrial background with good troubleshooting skills.<\/li><li>Working knowledge of E&amp;I equipment in an industrial plant is required.<\/li><li>Read and understand one-line diagrams &amp; schematics.<\/li><li>Ability to read, write, and interpret documents such as work orders, blueprints, mechanical and electrical drawings, safety rules, standard operating procedures, maintenance instructions, and procedural manuals.<\/li><li>Ability to detect potential problems through observation in the field.<\/li><li>Previous experience operating heavy equipment is desired.<\/li><li>Perform basic mathematical calculations is required.&nbsp;<\/li><li>Must have a telephone and be open to callouts.<\/li><li>Must be able to work extended shift to complete repairs and keep major and critical equipment running.<\/li><li>Able to work shift work, seven days a week including holidays and be flexible to schedule changes as required per operation needs.<\/li><li>Effectively communicate and interact with supervisors, managers, and peers.<\/li><li>Demonstrate the ability to operate a computer.<\/li><li>Must have a Valid Driver\u2019s License and reliable mode of transportation.<\/li><li>Self-Starter and able to work with minimal supervision<\/li><li>Must be able to tolerate working outside in severe weather conditions as well as exposure to high temperature, noise, and dust.<\/li><li>Must be able to access all plant locations and perform the essential job duties of this position, including heavy lifting over 50 pounds. This could include heights of 120 feet, confined spaces, climbing ladders or stairs, and accessing tunnels.&nbsp;<\/li><li>Must perform all tasks in a timely and efficient manner.<\/li><\/ul>","post_title":"Electrician","post_link":"https:\/\/turnerstaffing.com\/position\/electrician-2\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Mid Level","%location_country%":"United States","%location_city%":"New Braunfels","%location_state_id%":"TX","%location_state_name%":"Texas","%location_city_state%":"New Braunfels, TX","%education%":"High School or equivalent","%department%":"","%description%":"<p><strong>POSITION SUMMARY: <\/strong><\/p>\n<p>A strong team member will perform duties including but not limited to electrician and all aspects of mechanical maintenance. Team member will be able to troubleshoot issues to ensure all electrical and mechanical components are in good working order throughout the plant.<\/p>\n<p><\/p>\n<p><strong>RESPONSIBILITIES &amp; EXPECTATIONS:<\/strong><\/p>\n<p><strong>Electrical<\/strong><\/p>\n<ul><li>Perform basic electrical calculations.<\/li><li>Perform tasks with all electrical test equipment (voltage meters, meggers, current generators, loop calibrators, etc.)<\/li><li>Fabricate and install conduit.<\/li><li>Troubleshoot and maintain motor control circuits.<\/li><li>Troubleshoot and maintain automation equipment and associated instrumentations.<\/li><li>Troubleshoot and maintain variable speed drives.<\/li><li>Proficient in working with low to medium voltage power (4,160V) and associated systems.<\/li><li>Willing to perform any other assigned tasks not specifically indicated.<\/li><\/ul>\n<p><\/p>\n<p><strong>Maintenance<\/strong><\/p>\n<ul><li>Understand the installation and maintenance of all types of bearings.<\/li><li>Perform shaft alignments using precision tools.<\/li><li>Must be able to disassemble and rebuild all types of crushing, screening, and conveying equipment.<\/li><li>Perform preventive maintenance checks and report findings verbally and in writing.<\/li><li>Perform preventative maintenance tasks on the mechanical systems including inspection and lubrication.&nbsp;<\/li><li>Troubleshoot and perform repairs to hydraulic systems and pneumatics systems.<\/li><li>Troubleshoot and perform repairs on various environmental mitigation equipment.<\/li><li>Perform some mechanical work.<\/li><li>Willing to perform any other assigned tasks not specifically indicated.<\/li><\/ul>\n<p><\/p>\n<p><strong>Training<\/strong><\/p>\n<ul><li>Operate small mobile equipment.<\/li><li>Willing to train on any new equipment installations.<\/li><li>Willing to perform any other assigned tasks not specifically indicated.<\/li><\/ul>\n<p><br><strong>Safety <\/strong><\/p>\n<ul><li>Must be well versed on all aspects of safety.<\/li><li>Comply with company, state, and governmental health and safety regulations at all times.<\/li><li>Complete and document Workplace Inspections in a timely manner.<\/li><li>Ensure maintenance tools are kept in good condition, repaired or replaced when necessary.<\/li><\/ul>\n<p><\/p>\n<p><strong>ATTRIBUTES:<\/strong><\/p>\n<ul><li>Good decision-making skills regarding safety<\/li><li>Knowledgeable of current environmental regulations and practices as they relate to the lime industry.<\/li><li><strong>Electrical<\/strong><ul><li>Perform basic electrical calculations.<\/li><li>Perform tasks with all electrical test equipment (voltage meters, meggers, current generators, loop calibrators, etc.)<\/li><li>Fabricate and install conduit.<\/li><li>Troubleshoot and maintain motor control circuits.<\/li><li>Troubleshoot and maintain automation equipment and associated instrumentations.<\/li><li>Troubleshoot and maintain variable speed drives.<\/li><li>Proficient in working with low to medium voltage power (4,160V) and associated systems.<\/li><li>Willing to perform any other assigned tasks not specifically indicated.<\/li><\/ul><\/li><\/ul>\n<p><\/p>\n<p><strong>Maintenance<\/strong><\/p>\n<ul><li>Understand the installation and maintenance of all types of bearings.<\/li><li>Perform shaft alignments using precision tools.<\/li><li>Must be able to disassemble and rebuild all types of crushing, screening, and conveying equipment.<\/li><li>Perform preventive maintenance checks and report findings verbally and in writing.<\/li><li>Perform preventative maintenance tasks on the mechanical systems including inspection and lubrication.&nbsp;<\/li><li>Troubleshoot and perform repairs to hydraulic systems and pneumatics systems.<\/li><li>Troubleshoot and perform repairs on various environmental mitigation equipment.<\/li><li>Perform some mechanical work.<\/li><li>Willing to perform any other assigned tasks not specifically indicated.<\/li><\/ul>\n<p><\/p>\n<p><strong>Training<\/strong><\/p>\n<ul><li>Operate small mobile equipment.<\/li><li>Willing to train on any new equipment installations.<\/li><li>Willing to perform any other assigned tasks not specifically indicated.<\/li><\/ul>\n<p><\/p>\n<p><strong>Safety <\/strong><\/p>\n<ul><li>Must be well versed on all aspects of safety.<\/li><li>Comply with company, state, and governmental health and safety regulations at all times.<\/li><li>Complete and document Workplace Inspections in a timely manner.<\/li><li>Ensure maintenance tools are kept in good condition, repaired or replaced when necessary.<\/li><\/ul>\n<p><br><\/p>\n\n\n<p><strong>PHYSICAL DEMANDS INCLUDE, BUT ARE NOT LIMITED TO: <\/strong><\/p>\n<p><\/p>\n<p><strong>ATTRIBUTES:<\/strong><\/p>\n<ul><li>&nbsp;3+ years or the ability to demonstrate electrical and instrumentation experience including some wiring and motor installation, and equipment troubleshooting<\/li><li>&nbsp;Completion of an apprenticeship program, technical program, or equivalent experience in industrial background.<\/li><li>High School Diploma or GED Equivalent.<\/li><li>Tolerate working outside in severe weather conditions as well as exposure to industrial high temperature, noise and dust.<\/li><li>Access all areas within a site which could include heights of 120 feet, confined spaces, climbing ladders or stairs, and accessing tunnels.<\/li><li>Able to lift over 50 pounds.<\/li><li>Workday or shift work and also be able to take call out as needed. Work as needed if there are issues with equipment in the plant after normal hours or weekends.<\/li><li>Good decision-making skills regarding safety<\/li><li>Knowledgeable of current environmental regulations and practices as they relate to the lime industry.<\/li><li>Proficient knowledge of E&amp;I, hydraulics and pneumatics to assist in troubleshooting equipment failures.<\/li><li>Industrial background with good troubleshooting skills.<\/li><li>Working knowledge of E&amp;I equipment in an industrial plant is required.<\/li><li>Read and understand one-line diagrams &amp; schematics.<\/li><li>Ability to read, write, and interpret documents such as work orders, blueprints, mechanical and electrical drawings, safety rules, standard operating procedures, maintenance instructions, and procedural manuals.<\/li><li>Ability to detect potential problems through observation in the field.<\/li><li>Previous experience operating heavy equipment is desired.<\/li><li>Perform basic mathematical calculations is required.&nbsp;<\/li><li>Must have a telephone and be open to callouts.<\/li><li>Must be able to work extended shift to complete repairs and keep major and critical equipment running.<\/li><li>Able to work shift work, seven days a week including holidays and be flexible to schedule changes as required per operation needs.<\/li><li>Effectively communicate and interact with supervisors, managers, and peers.<\/li><li>Demonstrate the ability to operate a computer.<\/li><li>Must have a Valid Driver\u2019s License and reliable mode of transportation.<\/li><li>Self-Starter and able to work with minimal supervision<\/li><li>Must be able to tolerate working outside in severe weather conditions as well as exposure to high temperature, noise, and dust.<\/li><li>Must be able to access all plant locations and perform the essential job duties of this position, including heavy lifting over 50 pounds. This could include heights of 120 feet, confined spaces, climbing ladders or stairs, and accessing tunnels.&nbsp;<\/li><li>Must perform all tasks in a timely and efficient manner.<\/li><\/ul>","%category%":"Other","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/fe8d2a7a8717-electrician","%breezy_id%":"fe8d2a7a8717","%breezy_friendly_id%":"fe8d2a7a8717-electrician","%breezy_created_date%":"2025-03-26T20:27:29.379Z","%breezy_updated_date%":"2025-03-26T20:29:04.661Z","%_wpgmp_location_city%":"New Braunfels","%_wpgmp_location_state%":"TX","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"New Braunfels, TX, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"29.702566","%_wpgmp_metabox_longitude%":"-98.1240635","%rank_math_internal_links_processed%":"1"}},"id":2298,"infowindow_disable":false},{"source":"post","title":"Haul Truck Driver &#8211; Mining","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Haul Truck Driver &#8211; Mining\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Turner Mining Group \u2013 Haul Truck Driver Do you love mining? Do you think differently? Are you ready to define&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/haul-truck-driver-mining\/\" name=\"Haul Truck Driver &#8211; Mining\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Turner Mining Group \u2013 Haul Truck Driver Do you love mining? Do you think differently? Are you ready to define&hellip;","address":"Baldwin Park, CA, USA","location":{"lat":"34.0852868","city":"Baldwin Park","state":"CA","country":"United States","lng":"-117.9608978","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/haul-truck-driver-mining\/","zoom":19,"extra_fields":{"post_excerpt":"Turner Mining Group \u2013 Haul Truck Driver Do you love mining? Do you think differently? Are you ready to define&hellip;","post_content":"<p><strong><u>Turner Mining Group \u2013 Haul Truck Driver<\/u><\/strong><\/p>\n<p>Do you love mining? Do you think differently? Are you ready to define the future of this industry?<\/p>\n<p>We\u2019ve been waiting for you! <\/p>\n<p>Turner Mining Group is committed to changing the way mining companies do business. We develop our people. We partner with our clients. We believe in win, win, win.<\/p>\n<p>We are looking for a dynamic and talented mining Haul Truck Drivers for our fast-growing, forward thinking mining services company headquartered in Bloomington, Indiana with our Operations team headquartered in Salt Lake City, Utah.<\/p>\n<p>Turner Mining Group is seeking an energetic mining professionals who can leverage their mining knowledge to expand upon our fast-growing business, creating best practices for equipment operations to ensure profitable operations.<\/p>\n<p>If you would like to get involved and make a large contribution in mining or minerals processing, then you may enjoy a position as Haul Truck Driver. This position is great for anyone who would like to begin a career in mining, has experience in a related industry but would like to learn about mining, or has experience as a miner but would like to grow into further positions with Turner Mining Group.<\/p>\n<p><strong>You<\/strong><\/p>\n<p>You want to work for a services company that is rapidly changing the way the largest materials producers do business. You are motivated by solving problems and partnering with our clients and suppliers. You want to work with great people and enjoy being a part of a strong team. You are a knowledgeable Operator who is not afraid to jump into every detail. You want to be in a place where continuous learning and growth is the norm. You are adaptable and able to juggle multiple initiatives concurrently.<\/p>\n<p><strong>Responsibilities:<\/strong><\/p>\n<ul><li>Operate and drive heavy haul trucks to transport tons of materials over short distances in a surface environment.<\/li><li>Perform inspections of vehicle systems, equipment and accessories such as tires, lights, turn signals and brakes<\/li><li>Ensure cargo is properly loaded according to safety requirements<\/li><li>Follow all safety policies, procedures and legislation<\/li><li>Maintain paper or electronic logbook<\/li><li>Communicate with Dispatcher and other Haul Truck Drivers using communication devices such as a two-ways radio or onboard computers<\/li><li>May drive special purpose vehicles, including end dump trucks, center dump truck units and water trucks<\/li><\/ul>\n<p><strong>Requirements:<\/strong><\/p>\n<ul><li>Safety oriented, awareness of everyone and everything that is around you<\/li><li>Strong work ethic<\/li><li>Willingness to learn<\/li><li>Ability to be flexible and to adapt<\/li><li>Experience with heavy equipment<\/li><li>Preferred to have MSHA training<\/li><\/ul>\n<p><strong>Benefits:<\/strong><\/p>\n<p>Turner Mining Group offers a competitive salary, an excellent work culture, career advancement opportunities. Our team offers a benefits program which includes Medical, Dental, Vision, Life, and a 401k with company match.<\/p>\n<p>At Turner Mining Group, we encourage and celebrate an inclusive environment for all employees and are proud to be an equal opportunity workplace and affirmative action employer.<\/p>","post_title":"Haul Truck Driver &#8211; Mining","post_link":"https:\/\/turnerstaffing.com\/position\/haul-truck-driver-mining\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Entry Level","%location_country%":"United States","%location_city%":"Baldwin Park","%location_state_id%":"CA","%location_state_name%":"California","%location_city_state%":"Baldwin Park, CA","%education%":"Unspecified","%department%":"Operations","%description%":"<p><strong><u>Turner Mining Group \u2013 Haul Truck Driver<\/u><\/strong><\/p>\n<p>Do you love mining? Do you think differently? Are you ready to define the future of this industry?<\/p>\n<p>We\u2019ve been waiting for you! <\/p>\n<p>Turner Mining Group is committed to changing the way mining companies do business. We develop our people. We partner with our clients. We believe in win, win, win.<\/p>\n<p>We are looking for a dynamic and talented mining Haul Truck Drivers for our fast-growing, forward thinking mining services company headquartered in Bloomington, Indiana with our Operations team headquartered in Salt Lake City, Utah.<\/p>\n<p>Turner Mining Group is seeking an energetic mining professionals who can leverage their mining knowledge to expand upon our fast-growing business, creating best practices for equipment operations to ensure profitable operations.<\/p>\n<p>If you would like to get involved and make a large contribution in mining or minerals processing, then you may enjoy a position as Haul Truck Driver. This position is great for anyone who would like to begin a career in mining, has experience in a related industry but would like to learn about mining, or has experience as a miner but would like to grow into further positions with Turner Mining Group.<\/p>\n<p><strong>You<\/strong><\/p>\n<p>You want to work for a services company that is rapidly changing the way the largest materials producers do business. You are motivated by solving problems and partnering with our clients and suppliers. You want to work with great people and enjoy being a part of a strong team. You are a knowledgeable Operator who is not afraid to jump into every detail. You want to be in a place where continuous learning and growth is the norm. You are adaptable and able to juggle multiple initiatives concurrently.<\/p>\n<p><strong>Responsibilities:<\/strong><\/p>\n<ul><li>Operate and drive heavy haul trucks to transport tons of materials over short distances in a surface environment.<\/li><li>Perform inspections of vehicle systems, equipment and accessories such as tires, lights, turn signals and brakes<\/li><li>Ensure cargo is properly loaded according to safety requirements<\/li><li>Follow all safety policies, procedures and legislation<\/li><li>Maintain paper or electronic logbook<\/li><li>Communicate with Dispatcher and other Haul Truck Drivers using communication devices such as a two-ways radio or onboard computers<\/li><li>May drive special purpose vehicles, including end dump trucks, center dump truck units and water trucks<\/li><\/ul>\n<p><strong>Requirements:<\/strong><\/p>\n<ul><li>Safety oriented, awareness of everyone and everything that is around you<\/li><li>Strong work ethic<\/li><li>Willingness to learn<\/li><li>Ability to be flexible and to adapt<\/li><li>Experience with heavy equipment<\/li><li>Preferred to have MSHA training<\/li><\/ul>\n<p><strong>Benefits:<\/strong><\/p>\n<p>Turner Mining Group offers a competitive salary, an excellent work culture, career advancement opportunities. Our team offers a benefits program which includes Medical, Dental, Vision, Life, and a 401k with company match.<\/p>\n<p>At Turner Mining Group, we encourage and celebrate an inclusive environment for all employees and are proud to be an equal opportunity workplace and affirmative action employer.<\/p>","%category%":"Operations","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/0259249c7ce4-haul-truck-driver-mining","%breezy_id%":"0259249c7ce4","%breezy_friendly_id%":"0259249c7ce4-haul-truck-driver-mining","%breezy_created_date%":"2025-03-26T13:51:28.491Z","%breezy_updated_date%":"2025-03-26T13:52:25.534Z","%_wpgmp_location_city%":"Baldwin Park","%_wpgmp_location_state%":"CA","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Baldwin Park, CA, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"34.0852868","%_wpgmp_metabox_longitude%":"-117.9608978","%rank_math_internal_links_processed%":"1"}},"id":2296,"infowindow_disable":false},{"source":"post","title":"Superintendent &#8211; Mining","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Superintendent &#8211; Mining\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Turner Mining Group &#8211; Project Superintendent We are always looking for super talented individuals to join our team! Do you&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/superintendent-mining\/\" name=\"Superintendent &#8211; Mining\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Turner Mining Group &#8211; Project Superintendent We are always looking for super talented individuals to join our team! Do you&hellip;","address":"Baldwin Park, CA, USA","location":{"lat":"34.0852868","city":"Baldwin Park","state":"CA","country":"United States","lng":"-117.9608978","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/superintendent-mining\/","zoom":19,"extra_fields":{"post_excerpt":"Turner Mining Group &#8211; Project Superintendent We are always looking for super talented individuals to join our team! Do you&hellip;","post_content":"<p><strong><u>Turner Mining Group - Project Superintendent <\/u><\/strong><\/p>\n<p>We are always looking for super talented individuals to join our team!<\/p>\n<p>Do you love mining? Do you think differently? Are you ready to define the future of this industry?<\/p>\n<p>We\u2019ve been waiting for you! Turner Mining Group is committed to changing the way mining companies do business. We develop our people. We partner with our clients. We believe in win, win, win.<\/p>\n<p>We are looking for a dynamic and talented mining industry leader to fill a Project Superintendent role at our fast-growing, forward thinking mining services company.<\/p>\n<p>Turner Mining Group is seeking an energetic mining professional who can leverage their mining industry experience to expand upon our fast-growing business, creating best practices for operations management and scalable business processes to ensure profitable projects. <\/p>\n<p>This person will function as a Project Superintendent, overseeing mining operations, work directly with the Senior Vice President of Mining, develop and mentor on-site management, and coordinating with home-office team. Leadership and an ability to problem solve while ensuring mining operations remain on budget and ahead of schedule. This is an opportunity to work as part of the executive leadership team in a fast-paced and flexible environment.<\/p>\n<p><strong>You<\/strong><\/p>\n<p>You want to work for a services company that is rapidly changing the way the largest mining producers do business. You are motivated by solving problems and partnering with our clients and suppliers. You want to work with great people and enjoy being a part of a strong team. You are a seasoned mining leader who is not afraid to jump into every detail. You want to be in a place where continuous learning and growth is the norm. You are adaptable and able to juggle multiple initiatives concurrently.<\/p>\n<p><strong>Position Overview<\/strong><\/p>\n<p>The Project Superintendent primary responsibility is to oversee mining operations within Turner Mining Group. This will include managing the operational and financial performance of projects, implementing processes to ensure effective personnel growth, equipment readiness, client interactions and problem solving and implementing systems and tools to increase efficiency and ensure profitability. Position reports directly to the Director of Operations.<\/p>\n<p><strong>Key Responsibilities<\/strong><\/p>\n<ul><li>Conduct field personnel development by training and monitoring: Equipment operators, maintenance technicians, grade staking, GPS utilization, foremen\u2019s, etc.<\/li><li>Ownership for project budget, profitability, and cost control<\/li><li>Identify, assist with develop, and understand the key financial and operational metrics for success<\/li><li>Oversee operations for safety and compliance<\/li><li>Developing and leading fields teams to increase performance<\/li><li>Implement business division reporting and metrics reviews<\/li><li>Coordinate site needs, crews for scheduling, planning, and resources<\/li><li>Monitor forward-looking personnel requirements and vendor developments<\/li><li>Negotiate and manage client and vendor relationships<\/li><li>Approve appropriate invoices and proposal submissions<\/li><li>Assist Biz Dev &amp; Estimation Team with Pre-Bid site visits, analysis, and work plans for project proposals<\/li><\/ul>\n<p><strong>Essential Skills &amp; Knowledge<\/strong><\/p>\n<ul><li>Detailed understanding of civil and mining operations<\/li><li>General understanding of business leadership<\/li><li>Ability to oversee operational and organizational performance for mining projects<\/li><li>Solid understanding of financial and operational reporting<\/li><li>Ability to quantify and explain variances to owners and executives succinctly and clearly<\/li><li>Proficiency in civil and mining best practices to perform project management<\/li><li>Intelligent with demonstrated results from creativity<\/li><li>Willingness to learn what is takes to run growing and successful teams<\/li><li>Strong organizational, interpersonal, and written communication skill<\/li><li>Gifted person who can prioritize and balance competing initiatives and activities<\/li><li>Knack for continuous improvement of processes, solution-based issue resolution and outcomes<\/li><li>Organized, problem solver and solution developer, who can work with workers, engineers and owner teams<\/li><li>Believe in the power of culture with strong leadership qualities<\/li><\/ul>\n<p><strong>Benefits<\/strong><\/p>\n<p>Turner Mining Group offers a competitive salary, an excellent work culture, career advancement opportunities. Our team offers a benefits program which includes Medical, Dental, Vision, Life, and a 401k with company match. We believe in a work life balance and established a Paid Time Off policy as well as paid time off for major holidays.<\/p>\n<p>At Turner Mining Group, we encourage and celebrate an inclusive environment for all employees and are proud to be an equal opportunity workplace and affirmative action employer.<\/p>","post_title":"Superintendent &#8211; Mining","post_link":"https:\/\/turnerstaffing.com\/position\/superintendent-mining\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Associate","%location_country%":"United States","%location_city%":"Baldwin Park","%location_state_id%":"CA","%location_state_name%":"California","%location_city_state%":"Baldwin Park, CA","%education%":"Unspecified","%department%":"Operations","%description%":"<p><strong><u>Turner Mining Group - Project Superintendent <\/u><\/strong><\/p>\n<p>We are always looking for super talented individuals to join our team!<\/p>\n<p>Do you love mining? Do you think differently? Are you ready to define the future of this industry?<\/p>\n<p>We\u2019ve been waiting for you! Turner Mining Group is committed to changing the way mining companies do business. We develop our people. We partner with our clients. We believe in win, win, win.<\/p>\n<p>We are looking for a dynamic and talented mining industry leader to fill a Project Superintendent role at our fast-growing, forward thinking mining services company.<\/p>\n<p>Turner Mining Group is seeking an energetic mining professional who can leverage their mining industry experience to expand upon our fast-growing business, creating best practices for operations management and scalable business processes to ensure profitable projects. <\/p>\n<p>This person will function as a Project Superintendent, overseeing mining operations, work directly with the Senior Vice President of Mining, develop and mentor on-site management, and coordinating with home-office team. Leadership and an ability to problem solve while ensuring mining operations remain on budget and ahead of schedule. This is an opportunity to work as part of the executive leadership team in a fast-paced and flexible environment.<\/p>\n<p><strong>You<\/strong><\/p>\n<p>You want to work for a services company that is rapidly changing the way the largest mining producers do business. You are motivated by solving problems and partnering with our clients and suppliers. You want to work with great people and enjoy being a part of a strong team. You are a seasoned mining leader who is not afraid to jump into every detail. You want to be in a place where continuous learning and growth is the norm. You are adaptable and able to juggle multiple initiatives concurrently.<\/p>\n<p><strong>Position Overview<\/strong><\/p>\n<p>The Project Superintendent primary responsibility is to oversee mining operations within Turner Mining Group. This will include managing the operational and financial performance of projects, implementing processes to ensure effective personnel growth, equipment readiness, client interactions and problem solving and implementing systems and tools to increase efficiency and ensure profitability. Position reports directly to the Director of Operations.<\/p>\n<p><strong>Key Responsibilities<\/strong><\/p>\n<ul><li>Conduct field personnel development by training and monitoring: Equipment operators, maintenance technicians, grade staking, GPS utilization, foremen\u2019s, etc.<\/li><li>Ownership for project budget, profitability, and cost control<\/li><li>Identify, assist with develop, and understand the key financial and operational metrics for success<\/li><li>Oversee operations for safety and compliance<\/li><li>Developing and leading fields teams to increase performance<\/li><li>Implement business division reporting and metrics reviews<\/li><li>Coordinate site needs, crews for scheduling, planning, and resources<\/li><li>Monitor forward-looking personnel requirements and vendor developments<\/li><li>Negotiate and manage client and vendor relationships<\/li><li>Approve appropriate invoices and proposal submissions<\/li><li>Assist Biz Dev &amp; Estimation Team with Pre-Bid site visits, analysis, and work plans for project proposals<\/li><\/ul>\n<p><strong>Essential Skills &amp; Knowledge<\/strong><\/p>\n<ul><li>Detailed understanding of civil and mining operations<\/li><li>General understanding of business leadership<\/li><li>Ability to oversee operational and organizational performance for mining projects<\/li><li>Solid understanding of financial and operational reporting<\/li><li>Ability to quantify and explain variances to owners and executives succinctly and clearly<\/li><li>Proficiency in civil and mining best practices to perform project management<\/li><li>Intelligent with demonstrated results from creativity<\/li><li>Willingness to learn what is takes to run growing and successful teams<\/li><li>Strong organizational, interpersonal, and written communication skill<\/li><li>Gifted person who can prioritize and balance competing initiatives and activities<\/li><li>Knack for continuous improvement of processes, solution-based issue resolution and outcomes<\/li><li>Organized, problem solver and solution developer, who can work with workers, engineers and owner teams<\/li><li>Believe in the power of culture with strong leadership qualities<\/li><\/ul>\n<p><strong>Benefits<\/strong><\/p>\n<p>Turner Mining Group offers a competitive salary, an excellent work culture, career advancement opportunities. Our team offers a benefits program which includes Medical, Dental, Vision, Life, and a 401k with company match. We believe in a work life balance and established a Paid Time Off policy as well as paid time off for major holidays.<\/p>\n<p>At Turner Mining Group, we encourage and celebrate an inclusive environment for all employees and are proud to be an equal opportunity workplace and affirmative action employer.<\/p>","%category%":"Operations","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/091ee7433780-superintendent-mining","%breezy_id%":"091ee7433780","%breezy_friendly_id%":"091ee7433780-superintendent-mining","%breezy_created_date%":"2025-03-26T13:55:31.358Z","%breezy_updated_date%":"2025-03-26T13:58:39.629Z","%_wpgmp_location_city%":"Baldwin Park","%_wpgmp_location_state%":"CA","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Baldwin Park, CA, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"34.0852868","%_wpgmp_metabox_longitude%":"-117.9608978","%rank_math_internal_links_processed%":"1"}},"id":2297,"infowindow_disable":false},{"source":"post","title":"Laborer","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Laborer\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Turner Mining Group \u2013 Laborer Do you love mining? Do you think differently? Are you ready to define the future&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/laborer\/\" name=\"Laborer\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Turner Mining Group \u2013 Laborer Do you love mining? Do you think differently? Are you ready to define the future&hellip;","address":"Baldwin Park, CA, USA","location":{"lat":"34.0852868","city":"Baldwin Park","state":"CA","country":"United States","lng":"-117.9608978","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/laborer\/","zoom":19,"extra_fields":{"post_excerpt":"Turner Mining Group \u2013 Laborer Do you love mining? Do you think differently? Are you ready to define the future&hellip;","post_content":"<p><strong><u>Turner Mining Group \u2013 Laborer<\/u><\/strong><\/p>\n<p>Do you love mining? Do you think differently? Are you ready to define the future of this industry?<\/p>\n<p>We\u2019ve been waiting for you! Turner Mining Group is committed to changing the way mining companies do business. We develop our people. We partner with our clients. We believe in win, win, win.<\/p>\n<p>We are looking for a laborer for our fast-growing, forward thinking mining services company headquartered in Bloomington, Indiana with our Operations team headquartered in Salt Lake City, Utah.<\/p>\n<p>Turner Mining Group is seeking an energetic mining professionals who can leverage their mining knowledge to expand upon our fast-growing business, creating best practices for equipment operations to ensure profitable operations.<\/p>\n<p><strong>You<\/strong><\/p>\n<p>You want to work for a services company that is rapidly changing the way the largest materials producers do business. You are motivated by solving problems and partnering with our clients and suppliers. You want to work with great people and enjoy being a part of a strong team. You are a safety oriented, hard working individual who is not afraid to jump into every detail. You want to be in a place where continuous learning and growth is the norm. You are adaptable and able to juggle multiple initiatives concurrently.<\/p>\n<p><strong>Responsibilities:<\/strong><\/p>\n<ul><li>Laborer duties include directional flagging of heavy and light duty traffic, stormwater BMP installation, demo, install and repair fencing and assisting in site survey and staking.<\/li><li>Duties include driving a truck, dumping loads, performing all pre-shift inspections, some basic maintenance and upkeep, and working with teammates on crew to maximize production while always maintaining our safety rules and regulations.<\/li><li>May drive special purpose vehicles, including end dump trucks, center dump truck units and water trucks<\/li><\/ul>\n<p><strong>Requirements:<\/strong><\/p>\n<ul><li>Safety oriented, awareness of everyone and everything that is around you<\/li><li>Strong work ethic<\/li><li>Willingness to learn<\/li><li>Ability to be flexible and to adapt<\/li><li>Experience with heavy equipment<\/li><li>Preferred to have MSHA training<\/li><\/ul>\n<p><strong>Benefits:<\/strong><\/p>\n<p>Turner Mining Group offers a competitive salary, an excellent work culture, career advancement opportunities. Our team offers a benefits program which includes Medical, Dental, Vision, Life, and a 401k with company match.<\/p>\n<p>At Turner Mining Group, we encourage and celebrate an inclusive environment for all employees and are proud to be an equal opportunity workplace and affirmative action employer.<\/p>","post_title":"Laborer","post_link":"https:\/\/turnerstaffing.com\/position\/laborer\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Entry Level","%location_country%":"United States","%location_city%":"Baldwin Park","%location_state_id%":"CA","%location_state_name%":"California","%location_city_state%":"Baldwin Park, CA","%education%":"Unspecified","%department%":"Operations","%description%":"<p><strong><u>Turner Mining Group \u2013 Laborer<\/u><\/strong><\/p>\n<p>Do you love mining? Do you think differently? Are you ready to define the future of this industry?<\/p>\n<p>We\u2019ve been waiting for you! Turner Mining Group is committed to changing the way mining companies do business. We develop our people. We partner with our clients. We believe in win, win, win.<\/p>\n<p>We are looking for a laborer for our fast-growing, forward thinking mining services company headquartered in Bloomington, Indiana with our Operations team headquartered in Salt Lake City, Utah.<\/p>\n<p>Turner Mining Group is seeking an energetic mining professionals who can leverage their mining knowledge to expand upon our fast-growing business, creating best practices for equipment operations to ensure profitable operations.<\/p>\n<p><strong>You<\/strong><\/p>\n<p>You want to work for a services company that is rapidly changing the way the largest materials producers do business. You are motivated by solving problems and partnering with our clients and suppliers. You want to work with great people and enjoy being a part of a strong team. You are a safety oriented, hard working individual who is not afraid to jump into every detail. You want to be in a place where continuous learning and growth is the norm. You are adaptable and able to juggle multiple initiatives concurrently.<\/p>\n<p><strong>Responsibilities:<\/strong><\/p>\n<ul><li>Laborer duties include directional flagging of heavy and light duty traffic, stormwater BMP installation, demo, install and repair fencing and assisting in site survey and staking.<\/li><li>Duties include driving a truck, dumping loads, performing all pre-shift inspections, some basic maintenance and upkeep, and working with teammates on crew to maximize production while always maintaining our safety rules and regulations.<\/li><li>May drive special purpose vehicles, including end dump trucks, center dump truck units and water trucks<\/li><\/ul>\n<p><strong>Requirements:<\/strong><\/p>\n<ul><li>Safety oriented, awareness of everyone and everything that is around you<\/li><li>Strong work ethic<\/li><li>Willingness to learn<\/li><li>Ability to be flexible and to adapt<\/li><li>Experience with heavy equipment<\/li><li>Preferred to have MSHA training<\/li><\/ul>\n<p><strong>Benefits:<\/strong><\/p>\n<p>Turner Mining Group offers a competitive salary, an excellent work culture, career advancement opportunities. Our team offers a benefits program which includes Medical, Dental, Vision, Life, and a 401k with company match.<\/p>\n<p>At Turner Mining Group, we encourage and celebrate an inclusive environment for all employees and are proud to be an equal opportunity workplace and affirmative action employer.<\/p>","%category%":"Operations","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/50bb01f02132-laborer","%breezy_id%":"50bb01f02132","%breezy_friendly_id%":"50bb01f02132-laborer","%breezy_created_date%":"2025-03-26T13:48:46.455Z","%breezy_updated_date%":"2025-03-26T13:50:03.000Z","%_wpgmp_location_city%":"Baldwin Park","%_wpgmp_location_state%":"CA","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Baldwin Park, CA, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"34.0852868","%_wpgmp_metabox_longitude%":"-117.9608978","%rank_math_internal_links_processed%":"1"}},"id":2295,"infowindow_disable":false},{"source":"post","title":"Blade Operator","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Blade Operator\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Turner Mining Group \u2013 Heavy Equipment Operator Do you love mining? Do you think differently? Are you ready to define&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/blade-operator-2\/\" name=\"Blade Operator\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Turner Mining Group \u2013 Heavy Equipment Operator Do you love mining? Do you think differently? Are you ready to define&hellip;","address":"Baldwin Park, CA, USA","location":{"lat":"34.0852868","city":"Baldwin Park","state":"CA","country":"United States","lng":"-117.9608978","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/blade-operator-2\/","zoom":19,"extra_fields":{"post_excerpt":"Turner Mining Group \u2013 Heavy Equipment Operator Do you love mining? Do you think differently? Are you ready to define&hellip;","post_content":"<p><strong><u>Turner Mining Group \u2013 Heavy Equipment Operator<\/u><\/strong><\/p>\n<p>Do you love mining? Do you think differently? Are you ready to define the future of this industry?<\/p>\n<p>We\u2019ve been waiting for you! Turner Mining Group is committed to changing the way mining companies do business. We develop our people. We partner with our clients. We believe in win, win, win.<\/p>\n<p>We are looking for a dynamic and talented mining Heavy Equipment Operators for our fast-growing, forward thinking mining services company headquartered in Bloomington, Indiana with our Operations team headquartered in Salt Lake City, Utah.<\/p>\n<p>Turner Mining Group is seeking an energetic mining professionals who can leverage their mining knowledge to expand upon our fast-growing business, creating best practices for equipment operations to ensure profitable operations.<\/p>\n<p><strong>You<\/strong><\/p>\n<p>You want to work for a services company that is rapidly changing the way the largest materials producers do business. You are motivated by solving problems and partnering with our clients and suppliers. You want to work with great people and enjoy being a part of a strong team. You are a knowledgeable Operator who is not afraid to jump into every detail. You want to be in a place where continuous learning and growth is the norm. You are adaptable and able to juggle multiple initiatives concurrently.<\/p>\n<p><strong>Responsibilities:<\/strong><\/p>\n<ul><li>Operating heavy equipment including loaders, scrapers, blade, excavators, dozers, haul trucks, and other pieces of heavy equipment in a production environment<\/li><li>Performing all pre-shift inspections, some basic maintenance and upkeep<\/li><li>Working with teammates on crew to maximize production while always maintaining our safety rules and regulations.<\/li><\/ul>\n<p><strong>Requirements:<\/strong><\/p>\n<ul><li>Safety oriented, awareness of everyone and everything that is around you<\/li><li>Strong work ethic<\/li><li>Willingness to learn<\/li><li>Ability to be flexible and to adapt<\/li><li>Experience with heavy equipment<\/li><li>Preferred to have MSHA training<\/li><\/ul>\n<p><strong>Benefits:<\/strong><\/p>\n<p>Turner Mining Group offers a competitive salary, an excellent work culture, career advancement opportunities. Our team offers a benefits program which includes Medical, Dental, Vision, Life, and a 401k with company match.<\/p>\n<p>At Turner Mining Group, we encourage and celebrate an inclusive environment for all employees and are proud to be an equal opportunity workplace and affirmative action employer.<\/p>","post_title":"Blade Operator","post_link":"https:\/\/turnerstaffing.com\/position\/blade-operator-2\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Associate","%location_country%":"United States","%location_city%":"Baldwin Park","%location_state_id%":"CA","%location_state_name%":"California","%location_city_state%":"Baldwin Park, CA","%education%":"Unspecified","%department%":"Operations","%description%":"<p><strong><u>Turner Mining Group \u2013 Heavy Equipment Operator<\/u><\/strong><\/p>\n<p>Do you love mining? Do you think differently? Are you ready to define the future of this industry?<\/p>\n<p>We\u2019ve been waiting for you! Turner Mining Group is committed to changing the way mining companies do business. We develop our people. We partner with our clients. We believe in win, win, win.<\/p>\n<p>We are looking for a dynamic and talented mining Heavy Equipment Operators for our fast-growing, forward thinking mining services company headquartered in Bloomington, Indiana with our Operations team headquartered in Salt Lake City, Utah.<\/p>\n<p>Turner Mining Group is seeking an energetic mining professionals who can leverage their mining knowledge to expand upon our fast-growing business, creating best practices for equipment operations to ensure profitable operations.<\/p>\n<p><strong>You<\/strong><\/p>\n<p>You want to work for a services company that is rapidly changing the way the largest materials producers do business. You are motivated by solving problems and partnering with our clients and suppliers. You want to work with great people and enjoy being a part of a strong team. You are a knowledgeable Operator who is not afraid to jump into every detail. You want to be in a place where continuous learning and growth is the norm. You are adaptable and able to juggle multiple initiatives concurrently.<\/p>\n<p><strong>Responsibilities:<\/strong><\/p>\n<ul><li>Operating heavy equipment including loaders, scrapers, blade, excavators, dozers, haul trucks, and other pieces of heavy equipment in a production environment<\/li><li>Performing all pre-shift inspections, some basic maintenance and upkeep<\/li><li>Working with teammates on crew to maximize production while always maintaining our safety rules and regulations.<\/li><\/ul>\n<p><strong>Requirements:<\/strong><\/p>\n<ul><li>Safety oriented, awareness of everyone and everything that is around you<\/li><li>Strong work ethic<\/li><li>Willingness to learn<\/li><li>Ability to be flexible and to adapt<\/li><li>Experience with heavy equipment<\/li><li>Preferred to have MSHA training<\/li><\/ul>\n<p><strong>Benefits:<\/strong><\/p>\n<p>Turner Mining Group offers a competitive salary, an excellent work culture, career advancement opportunities. Our team offers a benefits program which includes Medical, Dental, Vision, Life, and a 401k with company match.<\/p>\n<p>At Turner Mining Group, we encourage and celebrate an inclusive environment for all employees and are proud to be an equal opportunity workplace and affirmative action employer.<\/p>","%category%":"Operations","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/797ede342858-blade-operator","%breezy_id%":"797ede342858","%breezy_friendly_id%":"797ede342858-blade-operator","%breezy_created_date%":"2025-03-26T13:32:51.997Z","%breezy_updated_date%":"2025-03-26T13:38:03.337Z","%_wpgmp_location_city%":"Baldwin Park","%_wpgmp_location_state%":"CA","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Baldwin Park, CA, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"34.0852868","%_wpgmp_metabox_longitude%":"-117.9608978","%rank_math_internal_links_processed%":"1"}},"id":2293,"infowindow_disable":false},{"source":"post","title":"Front End Loader Operator","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Front End Loader Operator\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Turner Mining Group \u2013 Haul Truck Driver Do you love mining? Do you think differently? Are you ready to define&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/front-end-loader-operator\/\" name=\"Front End Loader Operator\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Turner Mining Group \u2013 Haul Truck Driver Do you love mining? Do you think differently? Are you ready to define&hellip;","address":"Baldwin Park, CA, USA","location":{"lat":"34.0852868","city":"Baldwin Park","state":"CA","country":"United States","lng":"-117.9608978","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/front-end-loader-operator\/","zoom":19,"extra_fields":{"post_excerpt":"Turner Mining Group \u2013 Haul Truck Driver Do you love mining? Do you think differently? Are you ready to define&hellip;","post_content":"<p><strong><u>Turner Mining Group \u2013 Haul Truck Driver<\/u><\/strong><\/p>\n<p>Do you love mining? Do you think differently? Are you ready to define the future of this industry?<\/p>\n<p>We\u2019ve been waiting for you! <\/p>\n<p>Turner Mining Group is committed to changing the way mining companies do business. We develop our people. We partner with our clients. We believe in win, win, win.<\/p>\n<p>We are looking for a dynamic and talented mining Haul Truck Drivers for our fast-growing, forward thinking mining services company headquartered in Bloomington, Indiana with our Operations team headquartered in Salt Lake City, Utah.<\/p>\n<p>Turner Mining Group is seeking an energetic mining professionals who can leverage their mining knowledge to expand upon our fast-growing business, creating best practices for equipment operations to ensure profitable operations.<\/p>\n<p>If you would like to get involved and make a large contribution in mining or minerals processing, then you may enjoy a position as Haul Truck Driver. This position is great for anyone who would like to begin a career in mining, has experience in a related industry but would like to learn about mining, or has experience as a miner but would like to grow into further positions with Turner Mining Group.<\/p>\n<p><strong>You<\/strong><\/p>\n<p>You want to work for a services company that is rapidly changing the way the largest materials producers do business. You are motivated by solving problems and partnering with our clients and suppliers. You want to work with great people and enjoy being a part of a strong team. You are a knowledgeable Operator who is not afraid to jump into every detail. You want to be in a place where continuous learning and growth is the norm. You are adaptable and able to juggle multiple initiatives concurrently.<\/p>\n<p><strong>Responsibilities:<\/strong><\/p>\n<ul><li>Operate and drive heavy haul trucks to transport tons of materials over short distances in a surface environment.<\/li><li>Perform inspections of vehicle systems, equipment and accessories such as tires, lights, turn signals and brakes<\/li><li>Ensure cargo is properly loaded according to safety requirements<\/li><li>Follow all safety policies, procedures and legislation<\/li><li>Maintain paper or electronic logbook<\/li><li>Communicate with Dispatcher and other Haul Truck Drivers using communication devices such as a two-ways radio or onboard computers<\/li><li>May drive special purpose vehicles, including end dump trucks, center dump truck units and water trucks<\/li><\/ul>\n<p><strong>Requirements:<\/strong><\/p>\n<ul><li>Safety oriented, awareness of everyone and everything that is around you<\/li><li>Strong work ethic<\/li><li>Willingness to learn<\/li><li>Ability to be flexible and to adapt<\/li><li>Experience with heavy equipment<\/li><li>Preferred to have MSHA training<\/li><\/ul>\n<p><strong>Benefits:<\/strong><\/p>\n<p>Turner Mining Group offers a competitive salary, an excellent work culture, career advancement opportunities. Our team offers a benefits program which includes Medical, Dental, Vision, Life, and a 401k with company match.<\/p>\n<p>At Turner Mining Group, we encourage and celebrate an inclusive environment for all employees and are proud to be an equal opportunity workplace and affirmative action employer.<\/p>","post_title":"Front End Loader Operator","post_link":"https:\/\/turnerstaffing.com\/position\/front-end-loader-operator\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Associate","%location_country%":"United States","%location_city%":"Baldwin Park","%location_state_id%":"CA","%location_state_name%":"California","%location_city_state%":"Baldwin Park, CA","%education%":"Unspecified","%department%":"","%description%":"<p><strong><u>Turner Mining Group \u2013 Haul Truck Driver<\/u><\/strong><\/p>\n<p>Do you love mining? Do you think differently? Are you ready to define the future of this industry?<\/p>\n<p>We\u2019ve been waiting for you! <\/p>\n<p>Turner Mining Group is committed to changing the way mining companies do business. We develop our people. We partner with our clients. We believe in win, win, win.<\/p>\n<p>We are looking for a dynamic and talented mining Haul Truck Drivers for our fast-growing, forward thinking mining services company headquartered in Bloomington, Indiana with our Operations team headquartered in Salt Lake City, Utah.<\/p>\n<p>Turner Mining Group is seeking an energetic mining professionals who can leverage their mining knowledge to expand upon our fast-growing business, creating best practices for equipment operations to ensure profitable operations.<\/p>\n<p>If you would like to get involved and make a large contribution in mining or minerals processing, then you may enjoy a position as Haul Truck Driver. This position is great for anyone who would like to begin a career in mining, has experience in a related industry but would like to learn about mining, or has experience as a miner but would like to grow into further positions with Turner Mining Group.<\/p>\n<p><strong>You<\/strong><\/p>\n<p>You want to work for a services company that is rapidly changing the way the largest materials producers do business. You are motivated by solving problems and partnering with our clients and suppliers. You want to work with great people and enjoy being a part of a strong team. You are a knowledgeable Operator who is not afraid to jump into every detail. You want to be in a place where continuous learning and growth is the norm. You are adaptable and able to juggle multiple initiatives concurrently.<\/p>\n<p><strong>Responsibilities:<\/strong><\/p>\n<ul><li>Operate and drive heavy haul trucks to transport tons of materials over short distances in a surface environment.<\/li><li>Perform inspections of vehicle systems, equipment and accessories such as tires, lights, turn signals and brakes<\/li><li>Ensure cargo is properly loaded according to safety requirements<\/li><li>Follow all safety policies, procedures and legislation<\/li><li>Maintain paper or electronic logbook<\/li><li>Communicate with Dispatcher and other Haul Truck Drivers using communication devices such as a two-ways radio or onboard computers<\/li><li>May drive special purpose vehicles, including end dump trucks, center dump truck units and water trucks<\/li><\/ul>\n<p><strong>Requirements:<\/strong><\/p>\n<ul><li>Safety oriented, awareness of everyone and everything that is around you<\/li><li>Strong work ethic<\/li><li>Willingness to learn<\/li><li>Ability to be flexible and to adapt<\/li><li>Experience with heavy equipment<\/li><li>Preferred to have MSHA training<\/li><\/ul>\n<p><strong>Benefits:<\/strong><\/p>\n<p>Turner Mining Group offers a competitive salary, an excellent work culture, career advancement opportunities. Our team offers a benefits program which includes Medical, Dental, Vision, Life, and a 401k with company match.<\/p>\n<p>At Turner Mining Group, we encourage and celebrate an inclusive environment for all employees and are proud to be an equal opportunity workplace and affirmative action employer.<\/p>","%category%":"Operations","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/983d47c90bf8-front-end-loader-operator","%breezy_id%":"983d47c90bf8","%breezy_friendly_id%":"983d47c90bf8-front-end-loader-operator","%breezy_created_date%":"2025-03-26T13:42:28.973Z","%breezy_updated_date%":"2025-03-26T13:44:01.214Z","%_wpgmp_location_city%":"Baldwin Park","%_wpgmp_location_state%":"CA","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Baldwin Park, CA, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"34.0852868","%_wpgmp_metabox_longitude%":"-117.9608978","%rank_math_internal_links_processed%":"1"}},"id":2294,"infowindow_disable":false},{"source":"post","title":"Dozer Operator","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Dozer Operator\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Turner Mining Group \u2013 Heavy Equipment Operator Do you love mining? Do you think differently? Are you ready to define&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/dozer-operator-2\/\" name=\"Dozer Operator\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Turner Mining Group \u2013 Heavy Equipment Operator Do you love mining? Do you think differently? Are you ready to define&hellip;","address":"Baldwin Park, CA, USA","location":{"lat":"34.0852868","city":"Baldwin Park","state":"CA","country":"United States","lng":"-117.9608978","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/dozer-operator-2\/","zoom":19,"extra_fields":{"post_excerpt":"Turner Mining Group \u2013 Heavy Equipment Operator Do you love mining? Do you think differently? Are you ready to define&hellip;","post_content":"<p><strong><u>Turner Mining Group \u2013 Heavy Equipment Operator<\/u><\/strong><\/p>\n<p>Do you love mining? Do you think differently? Are you ready to define the future of this industry?<\/p>\n<p>We\u2019ve been waiting for you! Turner Mining Group is committed to changing the way mining companies do business. We develop our people. We partner with our clients. We believe in win, win, win.<\/p>\n<p>We are looking for a dynamic and talented mining Heavy Equipment Operators for our fast-growing, forward thinking mining services company headquartered in Bloomington, Indiana with our Operations team headquartered in Salt Lake City, Utah.<\/p>\n<p>Turner Mining Group is seeking an energetic mining professionals who can leverage their mining knowledge to expand upon our fast-growing business, creating best practices for equipment operations to ensure profitable operations.<\/p>\n<p><strong>You<\/strong><\/p>\n<p>You want to work for a services company that is rapidly changing the way the largest materials producers do business. You are motivated by solving problems and partnering with our clients and suppliers. You want to work with great people and enjoy being a part of a strong team. You are a knowledgeable Operator who is not afraid to jump into every detail. You want to be in a place where continuous learning and growth is the norm. You are adaptable and able to juggle multiple initiatives concurrently.<\/p>\n<p><strong>Responsibilities:<\/strong><\/p>\n<ul><li>Operating heavy equipment including loaders, scrapers, blade, excavators, dozers, haul trucks, and other pieces of heavy equipment in a production environment<\/li><li>Performing all pre-shift inspections, some basic maintenance and upkeep<\/li><li>Working with teammates on crew to maximize production while always maintaining our safety rules and regulations.<\/li><\/ul>\n<p><strong>Requirements:<\/strong><\/p>\n<ul><li>Safety oriented, awareness of everyone and everything that is around you<\/li><li>Strong work ethic<\/li><li>Willingness to learn<\/li><li>Ability to be flexible and to adapt<\/li><li>Experience with heavy equipment<\/li><li>Preferred to have MSHA training<\/li><\/ul>\n<p><strong>Benefits:<\/strong><\/p>\n<p>Turner Mining Group offers a competitive salary, an excellent work culture, career advancement opportunities. Our team offers a benefits program which includes Medical, Dental, Vision, Life, and a 401k with company match.<\/p>\n<p>At Turner Mining Group, we encourage and celebrate an inclusive environment for all employees and are proud to be an equal opportunity workplace and affirmative action employer.<\/p>","post_title":"Dozer Operator","post_link":"https:\/\/turnerstaffing.com\/position\/dozer-operator-2\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Associate","%location_country%":"United States","%location_city%":"Baldwin Park","%location_state_id%":"CA","%location_state_name%":"California","%location_city_state%":"Baldwin Park, CA","%education%":"Unspecified","%department%":"","%description%":"<p><strong><u>Turner Mining Group \u2013 Heavy Equipment Operator<\/u><\/strong><\/p>\n<p>Do you love mining? Do you think differently? Are you ready to define the future of this industry?<\/p>\n<p>We\u2019ve been waiting for you! Turner Mining Group is committed to changing the way mining companies do business. We develop our people. We partner with our clients. We believe in win, win, win.<\/p>\n<p>We are looking for a dynamic and talented mining Heavy Equipment Operators for our fast-growing, forward thinking mining services company headquartered in Bloomington, Indiana with our Operations team headquartered in Salt Lake City, Utah.<\/p>\n<p>Turner Mining Group is seeking an energetic mining professionals who can leverage their mining knowledge to expand upon our fast-growing business, creating best practices for equipment operations to ensure profitable operations.<\/p>\n<p><strong>You<\/strong><\/p>\n<p>You want to work for a services company that is rapidly changing the way the largest materials producers do business. You are motivated by solving problems and partnering with our clients and suppliers. You want to work with great people and enjoy being a part of a strong team. You are a knowledgeable Operator who is not afraid to jump into every detail. You want to be in a place where continuous learning and growth is the norm. You are adaptable and able to juggle multiple initiatives concurrently.<\/p>\n<p><strong>Responsibilities:<\/strong><\/p>\n<ul><li>Operating heavy equipment including loaders, scrapers, blade, excavators, dozers, haul trucks, and other pieces of heavy equipment in a production environment<\/li><li>Performing all pre-shift inspections, some basic maintenance and upkeep<\/li><li>Working with teammates on crew to maximize production while always maintaining our safety rules and regulations.<\/li><\/ul>\n<p><strong>Requirements:<\/strong><\/p>\n<ul><li>Safety oriented, awareness of everyone and everything that is around you<\/li><li>Strong work ethic<\/li><li>Willingness to learn<\/li><li>Ability to be flexible and to adapt<\/li><li>Experience with heavy equipment<\/li><li>Preferred to have MSHA training<\/li><\/ul>\n<p><strong>Benefits:<\/strong><\/p>\n<p>Turner Mining Group offers a competitive salary, an excellent work culture, career advancement opportunities. Our team offers a benefits program which includes Medical, Dental, Vision, Life, and a 401k with company match.<\/p>\n<p>At Turner Mining Group, we encourage and celebrate an inclusive environment for all employees and are proud to be an equal opportunity workplace and affirmative action employer.<\/p>","%category%":"Operations","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/9594337acd1b-dozer-operator","%breezy_id%":"9594337acd1b","%breezy_friendly_id%":"9594337acd1b-dozer-operator","%breezy_created_date%":"2025-03-26T13:27:14.803Z","%breezy_updated_date%":"2025-03-26T13:29:30.061Z","%_wpgmp_location_city%":"Baldwin Park","%_wpgmp_location_state%":"CA","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Baldwin Park, CA, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"34.0852868","%_wpgmp_metabox_longitude%":"-117.9608978","%rank_math_internal_links_processed%":"1"}},"id":2292,"infowindow_disable":false},{"source":"post","title":"Industrial Electrician","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Industrial Electrician\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    A strong team member will perform duties including but not limited to electrician and all aspects of mechanical maintenance. Team&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/industrial-electrician\/\" name=\"Industrial Electrician\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"A strong team member will perform duties including but not limited to electrician and all aspects of mechanical maintenance. Team&hellip;","address":"Burnet, TX, USA","location":{"lat":"30.7582376","city":"Burnet","state":"TX","country":"United States","lng":"-98.2283585","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/industrial-electrician\/","zoom":19,"extra_fields":{"post_excerpt":"A strong team member will perform duties including but not limited to electrician and all aspects of mechanical maintenance. Team&hellip;","post_content":"<p>A strong team member will perform duties including but not limited to electrician and all aspects of mechanical maintenance. Team member will be able to troubleshoot issues to ensure all electrical and mechanical components are in good working order throughout the plant.<\/p>\n<p><strong>RESPONSIBILITIES &amp; EXPECTATIONS:<\/strong><\/p>\n<p><strong>Electrical<\/strong><\/p>\n<ul><li>Install and align electrical motors.<\/li><li>Set up &amp; troubleshoot A\/C drives.<\/li><li>Perform routine mechanical tasks. E.g. Replacement of bearings, idlers, dust collector bags, gearboxes, and drive belts will be required.<\/li><li>Able to troubleshoot control circuits with limited supervision.<\/li><li>Perform basic electrical calculations.<\/li><li>Perform tasks with all electrical test equipment (multi meters, meggers, current generators, Hart communicator, etc.)<\/li><li>Fabricate and install conduit.<\/li><li>Perform soldering operations.<\/li><li>Troubleshoot and maintain motor control circuits.<\/li><\/ul>\n<p><strong>Maintenance<\/strong><\/p>\n<ul><li>Must be able to disassemble and rebuild all types of crushing, screening, and conveying equipment.<\/li><li>Able to use equipment manuals, parts lists or blueprints to properly install, repair, or order parts.<\/li><li>Troubleshoot and perform repairs to hydraulic systems and pneumatic systems.<\/li><li>Troubleshoot and maintain variable speed drives.<\/li><li>Troubleshoot kiln instrumentation<\/li><li>Initiate work orders as required.<\/li><li>Ensure all inventory parts are correctly charged from warehouse.<\/li><li>Ensure all parts are available before starting job.<\/li><li>Operate extended forklift, manlift, or maintenance machinery to perform plant maintenance.<\/li><li>Perform preventive maintenance checks and report findings verbally and in writing<\/li><li>Navigate and understand NEC code book.<\/li><li>Assist with routine mechanical tasks. E.g. Replacement of bearings, idlers, dust collector bags, gearboxes, and drive belts will be required.<\/li><li>Initiate work orders as required.<\/li><li>Operate extended forklift, manlift, or maintenance machinery to perform plant maintenance.<\/li><\/ul>\n<p><strong>Training<\/strong><\/p>\n<ul><li>Willing to upgrade skills by participating in vendor and company-designated training.<\/li><li>Process knowledge of the CMMS System to ensure that work orders and checklists are complete accurately.<\/li><\/ul>\n<p><strong>Safety<\/strong><\/p>\n<ul><li>Comply with company, state, and governmental health and safety regulations at all times.<\/li><li>Complete and document Workplace Inspections in a timely manner.<\/li><li>Ensure maintenance tools are kept in good condition, repaired or replaced when necessary.<\/li><\/ul>\n<p><strong>ATTRIBUTES:<\/strong><\/p>\n<ul><li>Industrial background with good troubleshooting skills.<\/li><li>Must be able perform basic mathematical computations<\/li><li>Ability to detect potential problems through observation in the field.<\/li><li>Must be able to work shift work, seven days a week including holidays and be flexible to schedule changes.<\/li><li>Must have a telephone and be open to callouts.<\/li><li>Self-Motivated and must be able to work independently.<\/li><li>Good decision-making skills regarding safety.<\/li><li>Must be able to tolerate working outside in severe weather conditions as well as exposure to high temperature, noise, and dust.<\/li><li>Knowledge of basic computer skills.<\/li><li>Ability to read, write, and interpret documents such as work orders, blueprints, mechanical drawings, safety rules, standard operating procedures, maintenance instructions, and procedural manuals.<\/li><li>Knowledgeable of current environmental regulations and practices as they relate to the lime industry.<\/li><li>Must perform all tasks in a timely and efficient manner.<\/li><\/ul>\n<p><strong>PHYSICAL DEMANDS INCLUDE, BUT ARE NOT LIMITED TO:<\/strong><\/p>\n<ul><li>Must be able to tolerate working outside in severe weather conditions as well as exposure to high temperature, noise, and dust.<\/li><li>Must be able to access all plant locations and perform the essential job duties of this position. This could include heights of 190 feet, confined spaces, climbing ladders or stairs, and accessing tunnels<\/li><li>Ability to occasionally lift\/carry 50 pounds..<\/li><li>Previous experience operating heavy equipment is desired.<\/li><\/ul>\n<p><strong>REQUIRED EDUCATION:<\/strong><\/p>\n<ul><li>High School Diploma or GED equivalent.<\/li><\/ul>\n<p><strong>REQUIRED EXPERIENCE:<\/strong><\/p>\n<ul><li>5+ years electrical experience, and demonstration of safe work practices. Basic electrical and safety knowledge required.<\/li><\/ul>\n<p><strong>PREFERRED EXPERIENCE:<\/strong><\/p>\n<ul><li>Completion of an apprenticeship program, technical program, or equivalent experience in industrial background.<\/li><\/ul>","post_title":"Industrial Electrician","post_link":"https:\/\/turnerstaffing.com\/position\/industrial-electrician\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Mid Level","%location_country%":"United States","%location_city%":"Burnet","%location_state_id%":"TX","%location_state_name%":"Texas","%location_city_state%":"Burnet, TX","%education%":"High School or equivalent","%department%":"","%description%":"<p>A strong team member will perform duties including but not limited to electrician and all aspects of mechanical maintenance. Team member will be able to troubleshoot issues to ensure all electrical and mechanical components are in good working order throughout the plant.<\/p>\n<p><strong>RESPONSIBILITIES &amp; EXPECTATIONS:<\/strong><\/p>\n<p><strong>Electrical<\/strong><\/p>\n<ul><li>Install and align electrical motors.<\/li><li>Set up &amp; troubleshoot A\/C drives.<\/li><li>Perform routine mechanical tasks. E.g. Replacement of bearings, idlers, dust collector bags, gearboxes, and drive belts will be required.<\/li><li>Able to troubleshoot control circuits with limited supervision.<\/li><li>Perform basic electrical calculations.<\/li><li>Perform tasks with all electrical test equipment (multi meters, meggers, current generators, Hart communicator, etc.)<\/li><li>Fabricate and install conduit.<\/li><li>Perform soldering operations.<\/li><li>Troubleshoot and maintain motor control circuits.<\/li><\/ul>\n<p><strong>Maintenance<\/strong><\/p>\n<ul><li>Must be able to disassemble and rebuild all types of crushing, screening, and conveying equipment.<\/li><li>Able to use equipment manuals, parts lists or blueprints to properly install, repair, or order parts.<\/li><li>Troubleshoot and perform repairs to hydraulic systems and pneumatic systems.<\/li><li>Troubleshoot and maintain variable speed drives.<\/li><li>Troubleshoot kiln instrumentation<\/li><li>Initiate work orders as required.<\/li><li>Ensure all inventory parts are correctly charged from warehouse.<\/li><li>Ensure all parts are available before starting job.<\/li><li>Operate extended forklift, manlift, or maintenance machinery to perform plant maintenance.<\/li><li>Perform preventive maintenance checks and report findings verbally and in writing<\/li><li>Navigate and understand NEC code book.<\/li><li>Assist with routine mechanical tasks. E.g. Replacement of bearings, idlers, dust collector bags, gearboxes, and drive belts will be required.<\/li><li>Initiate work orders as required.<\/li><li>Operate extended forklift, manlift, or maintenance machinery to perform plant maintenance.<\/li><\/ul>\n<p><strong>Training<\/strong><\/p>\n<ul><li>Willing to upgrade skills by participating in vendor and company-designated training.<\/li><li>Process knowledge of the CMMS System to ensure that work orders and checklists are complete accurately.<\/li><\/ul>\n<p><strong>Safety<\/strong><\/p>\n<ul><li>Comply with company, state, and governmental health and safety regulations at all times.<\/li><li>Complete and document Workplace Inspections in a timely manner.<\/li><li>Ensure maintenance tools are kept in good condition, repaired or replaced when necessary.<\/li><\/ul>\n<p><strong>ATTRIBUTES:<\/strong><\/p>\n<ul><li>Industrial background with good troubleshooting skills.<\/li><li>Must be able perform basic mathematical computations<\/li><li>Ability to detect potential problems through observation in the field.<\/li><li>Must be able to work shift work, seven days a week including holidays and be flexible to schedule changes.<\/li><li>Must have a telephone and be open to callouts.<\/li><li>Self-Motivated and must be able to work independently.<\/li><li>Good decision-making skills regarding safety.<\/li><li>Must be able to tolerate working outside in severe weather conditions as well as exposure to high temperature, noise, and dust.<\/li><li>Knowledge of basic computer skills.<\/li><li>Ability to read, write, and interpret documents such as work orders, blueprints, mechanical drawings, safety rules, standard operating procedures, maintenance instructions, and procedural manuals.<\/li><li>Knowledgeable of current environmental regulations and practices as they relate to the lime industry.<\/li><li>Must perform all tasks in a timely and efficient manner.<\/li><\/ul>\n<p><strong>PHYSICAL DEMANDS INCLUDE, BUT ARE NOT LIMITED TO:<\/strong><\/p>\n<ul><li>Must be able to tolerate working outside in severe weather conditions as well as exposure to high temperature, noise, and dust.<\/li><li>Must be able to access all plant locations and perform the essential job duties of this position. This could include heights of 190 feet, confined spaces, climbing ladders or stairs, and accessing tunnels<\/li><li>Ability to occasionally lift\/carry 50 pounds..<\/li><li>Previous experience operating heavy equipment is desired.<\/li><\/ul>\n<p><strong>REQUIRED EDUCATION:<\/strong><\/p>\n<ul><li>High School Diploma or GED equivalent.<\/li><\/ul>\n<p><strong>REQUIRED EXPERIENCE:<\/strong><\/p>\n<ul><li>5+ years electrical experience, and demonstration of safe work practices. Basic electrical and safety knowledge required.<\/li><\/ul>\n<p><strong>PREFERRED EXPERIENCE:<\/strong><\/p>\n<ul><li>Completion of an apprenticeship program, technical program, or equivalent experience in industrial background.<\/li><\/ul>","%category%":"Other","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/e3a5e8c20231-industrial-electrician","%breezy_id%":"e3a5e8c20231","%breezy_friendly_id%":"e3a5e8c20231-industrial-electrician","%breezy_created_date%":"2025-02-07T00:56:21.987Z","%breezy_updated_date%":"2025-03-27T17:05:18.974Z","%_wpgmp_location_city%":"Burnet","%_wpgmp_location_state%":"TX","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Burnet, TX, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"30.7582376","%_wpgmp_metabox_longitude%":"-98.2283585","%rank_math_internal_links_processed%":"1"}},"id":2291,"infowindow_disable":false},{"source":"post","title":"Haul Truck Driver","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Haul Truck Driver\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Operate 70-ton haul trucks (HD605-8 and\/or 775 CAT) proficiently and safely.&nbsp;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/haul-truck-driver-3\/\" name=\"Haul Truck Driver\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Operate 70-ton haul trucks (HD605-8 and\/or 775 CAT) proficiently and safely.&nbsp;","address":"Bridgeport, TX, USA","location":{"lat":"33.2101155","city":"Bridgeport","state":"TX","country":"United States","lng":"-97.7547552","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/haul-truck-driver-3\/","zoom":19,"extra_fields":{"post_excerpt":"Operate 70-ton haul trucks (HD605-8 and\/or 775 CAT) proficiently and safely.&nbsp;","post_content":"<p>Operate 70-ton haul trucks (HD605-8 and\/or 775 CAT) proficiently and safely.&nbsp;<\/p>","post_title":"Haul Truck Driver","post_link":"https:\/\/turnerstaffing.com\/position\/haul-truck-driver-3\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"","%location_country%":"United States","%location_city%":"Bridgeport","%location_state_id%":"TX","%location_state_name%":"Texas","%location_city_state%":"Bridgeport, TX","%education%":"","%department%":"","%description%":"<p>Operate 70-ton haul trucks (HD605-8 and\/or 775 CAT) proficiently and safely.&nbsp;<\/p>","%category%":"","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/6bf2eeec24ec-haul-truck-driver","%breezy_id%":"6bf2eeec24ec","%breezy_friendly_id%":"6bf2eeec24ec-haul-truck-driver","%breezy_created_date%":"2025-03-24T14:40:07.449Z","%breezy_updated_date%":"2025-03-24T14:41:06.674Z","%_wpgmp_location_city%":"Bridgeport","%_wpgmp_location_state%":"TX","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Bridgeport, TX, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"33.2101155","%_wpgmp_metabox_longitude%":"-97.7547552","%rank_math_internal_links_processed%":"1"}},"id":2284,"infowindow_disable":false},{"source":"post","title":"Haul Truck Driver &#8211; Mining","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Haul Truck Driver &#8211; Mining\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Turner Mining Group \u2013 Haul Truck Driver We are looking for a dynamic and talented mining Haul Truck Drivers for&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/haul-truck-driver-off-road\/\" name=\"Haul Truck Driver &#8211; Mining\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Turner Mining Group \u2013 Haul Truck Driver We are looking for a dynamic and talented mining Haul Truck Drivers for&hellip;","address":"Pacific, MO, USA","location":{"lat":"38.4819976","city":"Pacific","state":"MO","country":"United States","lng":"-90.7415194","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/haul-truck-driver-off-road\/","zoom":19,"extra_fields":{"post_excerpt":"Turner Mining Group \u2013 Haul Truck Driver We are looking for a dynamic and talented mining Haul Truck Drivers for&hellip;","post_content":"<p><strong><u>Turner Mining Group \u2013 Haul Truck Driver<\/u><\/strong><br><\/p>\n\n<p>We are looking for a dynamic and talented mining Haul Truck Drivers for our fast-growing, forward thinking mining services company headquartered in Bloomington, Indiana with our Operations team headquartered in Salt Lake City, Utah.<\/p>\n<p>Turner Mining Group is seeking an energetic mining professionals who can leverage their mining knowledge to expand upon our fast-growing business, creating best practices for equipment operations to ensure profitable operations.<\/p>\n<p>If you would like to get involved and make a large contribution in mining or minerals processing, then you may enjoy a position as Haul Truck Driver. This position is great for anyone who would like to begin a career in mining, has experience in a related industry but would like to learn about mining, or has experience as a miner but would like to grow into further positions with Turner Mining Group.<\/p>\n<p><strong>You<\/strong><\/p>\n<p>You want to work for a services company that is rapidly changing the way the largest materials producers do business. You are motivated by solving problems and partnering with our clients and suppliers. You want to work with great people and enjoy being a part of a strong team. You are a knowledgeable Operator who is not afraid to jump into every detail. You want to be in a place where continuous learning and growth is the norm. You are adaptable and able to juggle multiple initiatives concurrently.<\/p>\n<p><strong>Responsibilities:<\/strong><\/p>\n<ul><li>Operate and drive heavy haul trucks to transport tons of materials over short distances in a surface environment.<\/li><li>Perform inspections of vehicle systems, equipment and accessories such as tires, lights, turn signals and brakes<\/li><li>Ensure cargo is properly loaded according to safety requirements<\/li><li>Follow all safety policies, procedures and legislation<\/li><li>Maintain paper or electronic logbook<\/li><li>Communicate with Dispatcher and other Haul Truck Drivers using communication devices such as a two-ways radio or onboard computers<\/li><li>May drive special purpose vehicles, including end dump trucks, center dump truck units and water trucks<\/li><\/ul>\n<p><strong>Requirements:<\/strong><\/p>\n<ul><li>Safety oriented, awareness of everyone and everything that is around you<\/li><li>Strong work ethic<\/li><li>Willingness to learn<\/li><li>Ability to be flexible and to adapt<\/li><li>Experience with heavy equipment<\/li><li>Preferred to have MSHA training<\/li><\/ul>\n<p><strong>Benefits:<\/strong><\/p>\n<p>Turner Mining Group offers a competitive salary, an excellent work culture, career advancement opportunities. Our team offers a benefits program which includes Medical, Dental, Vision, Life, and a 401k with company match.<\/p>\n<p>At Turner Mining Group, we encourage and celebrate an inclusive environment for all employees and are proud to be an equal opportunity workplace and affirmative action employer.<\/p>","post_title":"Haul Truck Driver &#8211; Mining","post_link":"https:\/\/turnerstaffing.com\/position\/haul-truck-driver-off-road\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"","%location_country%":"United States","%location_city%":"Pacific","%location_state_id%":"MO","%location_state_name%":"Missouri","%location_city_state%":"Pacific, MO","%education%":"Unspecified","%department%":"Operations","%description%":"<p><strong><u>Turner Mining Group \u2013 Haul Truck Driver<\/u><\/strong><br><\/p>\n\n<p>We are looking for a dynamic and talented mining Haul Truck Drivers for our fast-growing, forward thinking mining services company headquartered in Bloomington, Indiana with our Operations team headquartered in Salt Lake City, Utah.<\/p>\n<p>Turner Mining Group is seeking an energetic mining professionals who can leverage their mining knowledge to expand upon our fast-growing business, creating best practices for equipment operations to ensure profitable operations.<\/p>\n<p>If you would like to get involved and make a large contribution in mining or minerals processing, then you may enjoy a position as Haul Truck Driver. This position is great for anyone who would like to begin a career in mining, has experience in a related industry but would like to learn about mining, or has experience as a miner but would like to grow into further positions with Turner Mining Group.<\/p>\n<p><strong>You<\/strong><\/p>\n<p>You want to work for a services company that is rapidly changing the way the largest materials producers do business. You are motivated by solving problems and partnering with our clients and suppliers. You want to work with great people and enjoy being a part of a strong team. You are a knowledgeable Operator who is not afraid to jump into every detail. You want to be in a place where continuous learning and growth is the norm. You are adaptable and able to juggle multiple initiatives concurrently.<\/p>\n<p><strong>Responsibilities:<\/strong><\/p>\n<ul><li>Operate and drive heavy haul trucks to transport tons of materials over short distances in a surface environment.<\/li><li>Perform inspections of vehicle systems, equipment and accessories such as tires, lights, turn signals and brakes<\/li><li>Ensure cargo is properly loaded according to safety requirements<\/li><li>Follow all safety policies, procedures and legislation<\/li><li>Maintain paper or electronic logbook<\/li><li>Communicate with Dispatcher and other Haul Truck Drivers using communication devices such as a two-ways radio or onboard computers<\/li><li>May drive special purpose vehicles, including end dump trucks, center dump truck units and water trucks<\/li><\/ul>\n<p><strong>Requirements:<\/strong><\/p>\n<ul><li>Safety oriented, awareness of everyone and everything that is around you<\/li><li>Strong work ethic<\/li><li>Willingness to learn<\/li><li>Ability to be flexible and to adapt<\/li><li>Experience with heavy equipment<\/li><li>Preferred to have MSHA training<\/li><\/ul>\n<p><strong>Benefits:<\/strong><\/p>\n<p>Turner Mining Group offers a competitive salary, an excellent work culture, career advancement opportunities. Our team offers a benefits program which includes Medical, Dental, Vision, Life, and a 401k with company match.<\/p>\n<p>At Turner Mining Group, we encourage and celebrate an inclusive environment for all employees and are proud to be an equal opportunity workplace and affirmative action employer.<\/p>","%category%":"Operations","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/d9e1112d4798-haul-truck-driver-mining","%breezy_id%":"d9e1112d4798","%breezy_friendly_id%":"d9e1112d4798-haul-truck-driver-mining","%breezy_created_date%":"2025-03-18T14:00:11.759Z","%breezy_updated_date%":"2025-03-25T13:14:49.643Z","%_wpgmp_location_city%":"Pacific","%_wpgmp_location_state%":"MO","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Pacific, MO, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"38.4819976","%_wpgmp_metabox_longitude%":"-90.7415194","%rank_math_internal_links_processed%":"1"}},"id":2283,"infowindow_disable":false},{"source":"post","title":"Excavator\/Rock Breaker Operator &#8211; Komatsu PC490\/Volvo 480","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Excavator\/Rock Breaker Operator &#8211; Komatsu PC490\/Volvo 480\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Responsibilities: Operating heavy equipment including loaders, scrapers, blade, excavators, dozers, haul trucks, and other pieces of heavy equipment in a&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/excavator-rock-breaker-operator-komatsu-pc490-volvo-480\/\" name=\"Excavator\/Rock Breaker Operator &#8211; Komatsu PC490\/Volvo 480\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Responsibilities: Operating heavy equipment including loaders, scrapers, blade, excavators, dozers, haul trucks, and other pieces of heavy equipment in a&hellip;","address":"Bridgeport, TX, USA","location":{"lat":"33.2101155","city":"Bridgeport","state":"TX","country":"United States","lng":"-97.7547552","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/excavator-rock-breaker-operator-komatsu-pc490-volvo-480\/","zoom":19,"extra_fields":{"post_excerpt":"Responsibilities: Operating heavy equipment including loaders, scrapers, blade, excavators, dozers, haul trucks, and other pieces of heavy equipment in a&hellip;","post_content":"<p><strong>Responsibilities:<\/strong><\/p>\n<ul><li>Operating heavy equipment including loaders, scrapers, blade, excavators, dozers, haul trucks, and other pieces of heavy equipment in a production environment<\/li><li>Performing all pre-shift inspections, some basic maintenance and upkeep<\/li><li>Working with teammates on crew to maximize production while always maintaining our safety rules and regulations.<\/li><\/ul>\n<p><strong>Requirements:<\/strong><\/p>\n<ul><li>Safety oriented, awareness of everyone and everything that is around you<\/li><li>Strong work ethic<\/li><li>Willingness to learn<\/li><li>Ability to be flexible and to adapt<\/li><li>Experience with heavy equipment<\/li><li>Preferred to have MSHA training<\/li><\/ul>\n<p><\/p>","post_title":"Excavator\/Rock Breaker Operator &#8211; Komatsu PC490\/Volvo 480","post_link":"https:\/\/turnerstaffing.com\/position\/excavator-rock-breaker-operator-komatsu-pc490-volvo-480\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"","%location_country%":"United States","%location_city%":"Bridgeport","%location_state_id%":"TX","%location_state_name%":"Texas","%location_city_state%":"Bridgeport, TX","%education%":"","%department%":"","%description%":"<p><strong>Responsibilities:<\/strong><\/p>\n<ul><li>Operating heavy equipment including loaders, scrapers, blade, excavators, dozers, haul trucks, and other pieces of heavy equipment in a production environment<\/li><li>Performing all pre-shift inspections, some basic maintenance and upkeep<\/li><li>Working with teammates on crew to maximize production while always maintaining our safety rules and regulations.<\/li><\/ul>\n<p><strong>Requirements:<\/strong><\/p>\n<ul><li>Safety oriented, awareness of everyone and everything that is around you<\/li><li>Strong work ethic<\/li><li>Willingness to learn<\/li><li>Ability to be flexible and to adapt<\/li><li>Experience with heavy equipment<\/li><li>Preferred to have MSHA training<\/li><\/ul>\n<p><\/p>","%category%":"","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/99ab5188b01a-excavator-rock-breaker-operator-komatsu-pc490-volvo-480","%breezy_id%":"99ab5188b01a","%breezy_friendly_id%":"99ab5188b01a-excavator-rock-breaker-operator-komatsu-pc490-volvo-480","%breezy_created_date%":"2024-10-29T18:15:45.553Z","%breezy_updated_date%":"2025-03-24T14:37:34.309Z","%_wpgmp_location_city%":"Bridgeport","%_wpgmp_location_state%":"TX","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Bridgeport, TX, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"33.2101155","%_wpgmp_metabox_longitude%":"-97.7547552","%rank_math_internal_links_processed%":"1"}},"id":2282,"infowindow_disable":false},{"source":"post","title":"Geologist","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Geologist\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    We are seeking a highly motivated and detail-oriented Core Logging Geologist to join our dynamic team. As an onsite, project-based&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/geologist-5\/\" name=\"Geologist\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"We are seeking a highly motivated and detail-oriented Core Logging Geologist to join our dynamic team. As an onsite, project-based&hellip;","address":"Fairbanks, AK, USA","location":{"lat":"64.8400511","city":"Fairbanks","state":"AK","country":"United States","lng":"-147.7199756","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/geologist-5\/","zoom":19,"extra_fields":{"post_excerpt":"We are seeking a highly motivated and detail-oriented Core Logging Geologist to join our dynamic team. As an onsite, project-based&hellip;","post_content":"<p>We are seeking a highly motivated and detail-oriented Core Logging Geologist to join our dynamic team. As an onsite, project-based Geologist, you will play a crucial role in the exploration and development of mineral resources. This position involves a combination of field and office work, requiring expertise in drill core logging and sampling, digital data entry, collation and interpretation of geological information, geologic mapping, and effective communication with drill contractors and fellow geologists.<\/p>\n<p><strong>Responsibilities:<\/strong><\/p>\n<ol><li>Drill Core Logging and Sampling:<p><\/p><ul><li>Conduct detailed and accurate logging of drill core samples.<\/li><li>Implement best practices for core sampling, ensuring high-quality data collection.<\/li><li>Collaborate with drilling teams to optimize core recovery and maintain data integrity.<\/li><\/ul><\/li><li>Digital Data Entry:<p><\/p><ul><li>Perform timely and precise digital entry of geological information using relevant software.<\/li><li>Organize and manage databases to facilitate efficient data retrieval and analysis.<\/li><li>Maintain a high level of accuracy in data entry to support reliable geological interpretations.<\/li><\/ul><\/li><li>Collation and Interpretation of Data:<p><\/p><ul><li>Analyze geological data to identify patterns, trends, and potential mineralization.<\/li><li>Collaborate with cross-functional teams to integrate geological findings into broader project objectives.<\/li><li>Contribute to the development of geological models and interpretations.<\/li><\/ul><\/li><li>Liaising with Drill Contractors and Other Geologists:<p><\/p><ul><li>Establish and maintain effective communication with drill contractors to ensure project objectives are met.<\/li><li>Collaborate with fellow geologists to share insights, coordinate activities, and enhance overall project understanding.<\/li><li>Provide clear and concise updates to project stakeholders, fostering a collaborative working environment.<\/li><\/ul><\/li><li>Geologic Mapping:<p><\/p><ul><li>Conduct geologic mapping to enhance the understanding of the project area.<\/li><li>Utilize mapping data to contribute to geological models and exploration strategies.<\/li><li>Document and communicate mapping findings to support broader geological interpretations.<\/li><\/ul><\/li><\/ol>\n<p><strong>Qualifications:<\/strong><\/p>\n<ul><li>Bachelor's or higher degree in Geology, Earth Sciences, or a related field.<\/li><li>Proven experience in drill core logging and sampling preferred.<\/li><li>Proficiency in digital data entry and geological software.<\/li><li>Strong analytical and problem-solving skills.<\/li><li>Excellent communication and interpersonal skills.<\/li><li>Ability to work collaboratively in a team and independently in the field.<\/li><li>Familiarity with geologic mapping techniques and tools.<br><\/li><\/ul>\n<p>Applicants must be authorized to work for ANY employer in the U.S. We are unable to sponsor or take over sponsorship of an employment Visa at this time.<\/p>","post_title":"Geologist","post_link":"https:\/\/turnerstaffing.com\/position\/geologist-5\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"","%location_country%":"United States","%location_city%":"Fairbanks","%location_state_id%":"AK","%location_state_name%":"Alaska","%location_city_state%":"Fairbanks, AK","%education%":"","%department%":"","%description%":"<p>We are seeking a highly motivated and detail-oriented Core Logging Geologist to join our dynamic team. As an onsite, project-based Geologist, you will play a crucial role in the exploration and development of mineral resources. This position involves a combination of field and office work, requiring expertise in drill core logging and sampling, digital data entry, collation and interpretation of geological information, geologic mapping, and effective communication with drill contractors and fellow geologists.<\/p>\n<p><strong>Responsibilities:<\/strong><\/p>\n<ol><li>Drill Core Logging and Sampling:<p><\/p><ul><li>Conduct detailed and accurate logging of drill core samples.<\/li><li>Implement best practices for core sampling, ensuring high-quality data collection.<\/li><li>Collaborate with drilling teams to optimize core recovery and maintain data integrity.<\/li><\/ul><\/li><li>Digital Data Entry:<p><\/p><ul><li>Perform timely and precise digital entry of geological information using relevant software.<\/li><li>Organize and manage databases to facilitate efficient data retrieval and analysis.<\/li><li>Maintain a high level of accuracy in data entry to support reliable geological interpretations.<\/li><\/ul><\/li><li>Collation and Interpretation of Data:<p><\/p><ul><li>Analyze geological data to identify patterns, trends, and potential mineralization.<\/li><li>Collaborate with cross-functional teams to integrate geological findings into broader project objectives.<\/li><li>Contribute to the development of geological models and interpretations.<\/li><\/ul><\/li><li>Liaising with Drill Contractors and Other Geologists:<p><\/p><ul><li>Establish and maintain effective communication with drill contractors to ensure project objectives are met.<\/li><li>Collaborate with fellow geologists to share insights, coordinate activities, and enhance overall project understanding.<\/li><li>Provide clear and concise updates to project stakeholders, fostering a collaborative working environment.<\/li><\/ul><\/li><li>Geologic Mapping:<p><\/p><ul><li>Conduct geologic mapping to enhance the understanding of the project area.<\/li><li>Utilize mapping data to contribute to geological models and exploration strategies.<\/li><li>Document and communicate mapping findings to support broader geological interpretations.<\/li><\/ul><\/li><\/ol>\n<p><strong>Qualifications:<\/strong><\/p>\n<ul><li>Bachelor's or higher degree in Geology, Earth Sciences, or a related field.<\/li><li>Proven experience in drill core logging and sampling preferred.<\/li><li>Proficiency in digital data entry and geological software.<\/li><li>Strong analytical and problem-solving skills.<\/li><li>Excellent communication and interpersonal skills.<\/li><li>Ability to work collaboratively in a team and independently in the field.<\/li><li>Familiarity with geologic mapping techniques and tools.<br><\/li><\/ul>\n<p>Applicants must be authorized to work for ANY employer in the U.S. We are unable to sponsor or take over sponsorship of an employment Visa at this time.<\/p>","%category%":"","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/12bb4c859bfd-geologist","%breezy_id%":"12bb4c859bfd","%breezy_friendly_id%":"12bb4c859bfd-geologist","%breezy_created_date%":"2024-12-18T13:51:26.822Z","%breezy_updated_date%":"2025-03-22T13:49:48.406Z","%_wpgmp_location_city%":"Fairbanks","%_wpgmp_location_state%":"AK","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Fairbanks, AK, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"64.8400511","%_wpgmp_metabox_longitude%":"-147.7199756","%rank_math_internal_links_processed%":"1"}},"id":2281,"infowindow_disable":false},{"source":"post","title":"IT Service Desk Technician","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    IT Service Desk Technician\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Position Description: The successful candidate will be responsible for the configuration, installation, troubleshooting and repair of personal computers, printers, telephones,&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/it-service-desk-technician-3\/\" name=\"IT Service Desk Technician\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Position Description: The successful candidate will be responsible for the configuration, installation, troubleshooting and repair of personal computers, printers, telephones,&hellip;","address":"Elko, NV, USA","location":{"lat":"40.8436459","city":"Elko","state":"NV","country":"United States","lng":"-115.7526187","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/it-service-desk-technician-3\/","zoom":19,"extra_fields":{"post_excerpt":"Position Description: The successful candidate will be responsible for the configuration, installation, troubleshooting and repair of personal computers, printers, telephones,&hellip;","post_content":"<p><strong><span style=\"color:#2f5496\">Position Description:<\/span><\/strong><\/p><p><span style=\"color:#555555\">The successful candidate will be responsible for the configuration, installation, troubleshooting and repair of personal computers, printers, telephones, mobile devices and data communications equipment; configuration and support of mobile devices; installation, configuration and support of desktop software systems; troubleshooting and resolving software and hardware problems; rotate through the role of on-call Help Desk technician on a periodic basis; perform other duties as assigned.<\/span><\/p><p><strong><span style=\"color:#2f5496\">Key Responsibilities:<\/span><\/strong><\/p><ul><li><span style=\"color:#555555\">Works at the Help Desk receives Help Desk tickets and telephone calls focusing on answering computer user requests for assistance, problem solving with a goal of first call resolution, providing troubleshooting and resolving of software, hardware, mobile and network problems.<\/span><\/li><li><span style=\"color:#555555\">Daily maintenance tasks, imaging computers and remediate broken clients<\/span><\/li><li><span style=\"color:#555555\">Assesses and collects essential issue data relative to problem and customer information for the dispatching a work to next tier support.<\/span><\/li><li><span style=\"color:#555555\">Provides first and second-level technical customer support; first level of support duties are receiving trouble calls via Help Desk tickets, telephone and e-mail and resolving issues within scope of role; if problems need a higher level support, the Help Desk technician will dispatch a service ticket to the appropriate higher level support personnel.<\/span><\/li><li><span style=\"color:#555555\">Provide local hands on support when higher level support needs physical assistance; second-level support is solving routine technical problems remotely from the Help Desk.<\/span><\/li><li><span style=\"color:#555555\">Responsible for day to day manning of the Help Desk ticketing system for all computer related trouble reported by local end users.<\/span><\/li><\/ul><p><strong><span style=\"color:#2f5496\">Qualifications:<\/span><\/strong><\/p><ul><li><span style=\"color:#555555\">Two (2) years of PC Technician experience in a business networking environment required<\/span><\/li><li><span style=\"color:#555555\">BS in Computer Sciences preferred<\/span><\/li><li><span style=\"color:#555555\">Microsoft MCSA or MCSE and A+ certifications preferred<\/span><\/li><li><span style=\"color:#555555\">Ability to lift and carry 50 pounds required<\/span><\/li><li><span style=\"color:#555555\">Ability to travel locally routinely required<\/span><\/li><li><span style=\"color:#555555\">Exceptional customer service\/interpersonal skills required<\/span><\/li><li><span style=\"color:#555555\">Demonstrated extensive knowledge of personal computers in a networked environment including data and telecommunications equipment required<\/span><\/li><li><span style=\"color:#555555\">Knowledge of and experience with, local area networks and associated protocols and equipment. Specifically, Microsoft Windows, IOS environments, mobile devices, firewall technology and TCP\/IP. Familiarity of Cisco networking equipment preferred<\/span><\/li><\/ul><p><strong><span style=\"color:#2f5496\">What we can Offer You <\/span><\/strong><\/p><ul><li><span style=\"color:#555555\">A comprehensive compensation package including benefits<\/span><\/li><li><span style=\"color:#555555\">Ability to make a difference and lasting impact<\/span><\/li><li><span style=\"color:#555555\">Work in a dynamic, collaborative, progressive, and high-performing team<\/span><\/li><li><span style=\"color:#555555\">An Opportunity to transform Traditional Mining into the future of Digital Mining<\/span><\/li><li><span style=\"color:#555555\">Opportunities to grow and learn with industry colleagues are endless<\/span><\/li><li>Must be authorized to work in the US without work visa sponsorship<\/li><\/ul>","post_title":"IT Service Desk Technician","post_link":"https:\/\/turnerstaffing.com\/position\/it-service-desk-technician-3\/","post_featured_image":"","post_categories":"","post_tags":"","%location_country%":"United States","%location_city%":"Elko","%location_state_id%":"NV","%location_city_state%":"Elko, NV","%description%":"<p><strong><span style=\"color:#2f5496;\">Position Description:<\/span><\/strong><\/p><p><span style=\"color:#555555;\">The successful candidate will be responsible for the configuration, installation, troubleshooting and repair of personal computers, printers, telephones, mobile devices and data communications equipment; configuration and support of mobile devices; installation, configuration and support of desktop software systems; troubleshooting and resolving software and hardware problems; rotate through the role of on-call Help Desk technician on a periodic basis; perform other duties as assigned.<\/span><\/p><p><strong><span style=\"color:#2f5496;\">Key Responsibilities:<\/span><\/strong><\/p><ul><li><span style=\"color:#555555;\">Works at the Help Desk receives Help Desk tickets and telephone calls focusing on answering computer user requests for assistance, problem solving with a goal of first call resolution, providing troubleshooting and resolving of software, hardware, mobile and network problems.<\/span><\/li><li><span style=\"color:#555555;\">Daily maintenance tasks, imaging computers and remediate broken clients<\/span><\/li><li><span style=\"color:#555555;\">Assesses and collects essential issue data relative to problem and customer information for the dispatching a work to next tier support.<\/span><\/li><li><span style=\"color:#555555;\">Provides first and second-level technical customer support; first level of support duties are receiving trouble calls via Help Desk tickets, telephone and e-mail and resolving issues within scope of role; if problems need a higher level support, the Help Desk technician will dispatch a service ticket to the appropriate higher level support personnel.<\/span><\/li><li><span style=\"color:#555555;\">Provide local hands on support when higher level support needs physical assistance; second-level support is solving routine technical problems remotely from the Help Desk.<\/span><\/li><li><span style=\"color:#555555;\">Responsible for day to day manning of the Help Desk ticketing system for all computer related trouble reported by local end users.<\/span><\/li><\/ul><p><strong><span style=\"color:#2f5496;\">Qualifications:<\/span><\/strong><\/p><ul><li><span style=\"color:#555555;\">Two (2) years of PC Technician experience in a business networking environment required<\/span><\/li><li><span style=\"color:#555555;\">BS in Computer Sciences preferred<\/span><\/li><li><span style=\"color:#555555;\">Microsoft MCSA or MCSE and A+ certifications preferred<\/span><\/li><li><span style=\"color:#555555;\">Ability to lift and carry 50 pounds required<\/span><\/li><li><span style=\"color:#555555;\">Ability to travel locally routinely required<\/span><\/li><li><span style=\"color:#555555;\">Exceptional customer service\/interpersonal skills required<\/span><\/li><li><span style=\"color:#555555;\">Demonstrated extensive knowledge of personal computers in a networked environment including data and telecommunications equipment required<\/span><\/li><li><span style=\"color:#555555;\">Knowledge of and experience with, local area networks and associated protocols and equipment. Specifically, Microsoft Windows, IOS environments, mobile devices, firewall technology and TCP\/IP. Familiarity of Cisco networking equipment preferred<\/span><\/li><\/ul><p><strong><span style=\"color:#2f5496;\">What we can Offer You <\/span><\/strong><\/p><ul><li><span style=\"color:#555555;\">A comprehensive compensation package including benefits<\/span><\/li><li><span style=\"color:#555555;\">Ability to make a difference and lasting impact<\/span><\/li><li><span style=\"color:#555555;\">Work in a dynamic, collaborative, progressive, and high-performing team<\/span><\/li><li><span style=\"color:#555555;\">An Opportunity to transform Traditional Mining into the future of Digital Mining<\/span><\/li><li><span style=\"color:#555555;\">Opportunities to grow and learn with industry colleagues are endless<\/span><\/li><li>Must be authorized to work in the US without work visa sponsorship<\/li><\/ul>","%application_url%":"https:\/\/jobs.crelate.com\/portal\/turnerstaffinggroup\/job\/a98m8r3ous59o1eyyobc8rb7tr","%crelate_id%":"a98m8r3ous59o1eyyobc8rb7tr","%crelate_created_date%":"2025-03-21T12:41:57.43Z","%crelate_updated_date%":"2025-03-27T19:36:10.5Z","%_wpgmp_location_city%":"Elko","%_wpgmp_location_state%":"NV","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Elko, NV, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"40.8436459","%_wpgmp_metabox_longitude%":"-115.7526187","%rank_math_internal_links_processed%":"1"}},"id":2280,"infowindow_disable":false},{"source":"post","title":"Geologist","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Geologist\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    We are seeking a highly motivated and detail-oriented Core Logging Geologist to join our dynamic team. As an onsite, project-based&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/geologist-4\/\" name=\"Geologist\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"We are seeking a highly motivated and detail-oriented Core Logging Geologist to join our dynamic team. As an onsite, project-based&hellip;","address":"Fairbanks, AK, USA","location":{"lat":"64.8400511","city":"Fairbanks","state":"AK","country":"United States","lng":"-147.7199756","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/geologist-4\/","zoom":19,"extra_fields":{"post_excerpt":"We are seeking a highly motivated and detail-oriented Core Logging Geologist to join our dynamic team. As an onsite, project-based&hellip;","post_content":"<p style=\"color:#374151\">We are seeking a highly motivated and detail-oriented Core Logging Geologist to join our dynamic team. As an onsite, project-based Geologist, you will play a crucial role in the exploration and development of mineral resources. This position involves a combination of field and office work, requiring expertise in drill core logging and sampling, digital data entry, collation and interpretation of geological information, geologic mapping, and effective communication with drill contractors and fellow geologists.<\/p><p style=\"color:#374151\"><span style=\"color:var(--tw-prose-bold)\"><strong>Responsibilities:<\/strong><\/span><\/p><ol><li><p><span style=\"color:var(--tw-prose-bold)\">Drill Core Logging and Sampling:<\/span><\/p><ul><li>Conduct detailed and accurate logging of drill core samples.<\/li><li>Implement best practices for core sampling, ensuring high-quality data collection.<\/li><li>Collaborate with drilling teams to optimize core recovery and maintain data integrity.<\/li><\/ul><\/li><li><p><span style=\"color:var(--tw-prose-bold)\">Digital Data Entry:<\/span><\/p><ul><li>Perform timely and precise digital entry of geological information using relevant software.<\/li><li>Organize and manage databases to facilitate efficient data retrieval and analysis.<\/li><li>Maintain a high level of accuracy in data entry to support reliable geological interpretations.<\/li><\/ul><\/li><li><p><span style=\"color:var(--tw-prose-bold)\">Collation and Interpretation of Data:<\/span><\/p><ul><li>Analyze geological data to identify patterns, trends, and potential mineralization.<\/li><li>Collaborate with cross-functional teams to integrate geological findings into broader project objectives.<\/li><li>Contribute to the development of geological models and interpretations.<\/li><\/ul><\/li><li><p><span style=\"color:var(--tw-prose-bold)\">Liaising with Drill Contractors and Other Geologists:<\/span><\/p><ul><li>Establish and maintain effective communication with drill contractors to ensure project objectives are met.<\/li><li>Collaborate with fellow geologists to share insights, coordinate activities, and enhance overall project understanding.<\/li><li>Provide clear and concise updates to project stakeholders, fostering a collaborative working environment.<\/li><\/ul><\/li><\/ol><p><strong>Qualifications:<\/strong><\/p><ul><li>Bachelor's or higher degree in Geology, Earth Sciences, or a related field.<\/li><li>Proven experience in drill core logging and sampling preferred.<\/li><li>Proficiency in digital data entry and geological software.<\/li><li>Strong analytical and problem-solving skills.<\/li><li>Excellent communication and interpersonal skills.<\/li><li>Ability to work collaboratively in a team and independently in the field.<\/li><li>Familiarity with geologic mapping techniques and tools.<br \/><\/li><\/ul><p><span style=\"color:#222222\">Applicants must be authorized to work for ANY employer in the U.S. We are unable to sponsor or take over sponsorship of an employment visa at this time.<\/span><\/p>","post_title":"Geologist","post_link":"https:\/\/turnerstaffing.com\/position\/geologist-4\/","post_featured_image":"","post_categories":"","post_tags":"","%location_country%":"United States","%location_city%":"Fairbanks","%location_state_id%":"AK","%location_city_state%":"Fairbanks, AK","%description%":"<p style=\"color:#374151;\">We are seeking a highly motivated and detail-oriented Core Logging Geologist to join our dynamic team. As an onsite, project-based Geologist, you will play a crucial role in the exploration and development of mineral resources. This position involves a combination of field and office work, requiring expertise in drill core logging and sampling, digital data entry, collation and interpretation of geological information, geologic mapping, and effective communication with drill contractors and fellow geologists.<\/p><p style=\"color:#374151;\"><span style=\"color:var(--tw-prose-bold);\"><strong>Responsibilities:<\/strong><\/span><\/p><ol><li><p><span style=\"color:var(--tw-prose-bold);\">Drill Core Logging and Sampling:<\/span><\/p><ul><li>Conduct detailed and accurate logging of drill core samples.<\/li><li>Implement best practices for core sampling, ensuring high-quality data collection.<\/li><li>Collaborate with drilling teams to optimize core recovery and maintain data integrity.<\/li><\/ul><\/li><li><p><span style=\"color:var(--tw-prose-bold);\">Digital Data Entry:<\/span><\/p><ul><li>Perform timely and precise digital entry of geological information using relevant software.<\/li><li>Organize and manage databases to facilitate efficient data retrieval and analysis.<\/li><li>Maintain a high level of accuracy in data entry to support reliable geological interpretations.<\/li><\/ul><\/li><li><p><span style=\"color:var(--tw-prose-bold);\">Collation and Interpretation of Data:<\/span><\/p><ul><li>Analyze geological data to identify patterns, trends, and potential mineralization.<\/li><li>Collaborate with cross-functional teams to integrate geological findings into broader project objectives.<\/li><li>Contribute to the development of geological models and interpretations.<\/li><\/ul><\/li><li><p><span style=\"color:var(--tw-prose-bold);\">Liaising with Drill Contractors and Other Geologists:<\/span><\/p><ul><li>Establish and maintain effective communication with drill contractors to ensure project objectives are met.<\/li><li>Collaborate with fellow geologists to share insights, coordinate activities, and enhance overall project understanding.<\/li><li>Provide clear and concise updates to project stakeholders, fostering a collaborative working environment.<\/li><\/ul><\/li><\/ol><p><strong>Qualifications:<\/strong><\/p><ul><li>Bachelor's or higher degree in Geology, Earth Sciences, or a related field.<\/li><li>Proven experience in drill core logging and sampling preferred.<\/li><li>Proficiency in digital data entry and geological software.<\/li><li>Strong analytical and problem-solving skills.<\/li><li>Excellent communication and interpersonal skills.<\/li><li>Ability to work collaboratively in a team and independently in the field.<\/li><li>Familiarity with geologic mapping techniques and tools.<br \/><\/li><\/ul><p><span style=\"color:#222222;\">Applicants must be authorized to work for ANY employer in the U.S. We are unable to sponsor or take over sponsorship of an employment visa at this time.<\/span><\/p>","%application_url%":"https:\/\/jobs.crelate.com\/portal\/turnerstaffinggroup\/job\/1fuboyw4rpb86jacczwrupknao","%crelate_id%":"1fuboyw4rpb86jacczwrupknao","%crelate_created_date%":"2024-12-18T13:08:02.89Z","%crelate_updated_date%":"2025-03-28T18:11:13.36Z","%_wpgmp_location_city%":"Fairbanks","%_wpgmp_location_state%":"AK","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Fairbanks, AK, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"64.8400511","%_wpgmp_metabox_longitude%":"-147.7199756","%rank_math_internal_links_processed%":"1"}},"id":2279,"infowindow_disable":false},{"source":"post","title":"Geologist","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Geologist\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    We are seeking a highly motivated and detail-oriented Core Logging Geologist to join our dynamic team. As a Core Logging&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/geologist-3\/\" name=\"Geologist\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"We are seeking a highly motivated and detail-oriented Core Logging Geologist to join our dynamic team. As a Core Logging&hellip;","address":"Fairbanks, AK, USA","location":{"lat":"64.8400511","city":"Fairbanks","state":"AK","country":"United States","lng":"-147.7199756","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/geologist-3\/","zoom":19,"extra_fields":{"post_excerpt":"We are seeking a highly motivated and detail-oriented Core Logging Geologist to join our dynamic team. As a Core Logging&hellip;","post_content":"<p>We are seeking a highly motivated and detail-oriented Core Logging Geologist to join our dynamic team. As a Core Logging Geologist, you will play a crucial role in the exploration and development of mineral resources. This position involves a combination of field and office work, requiring expertise in drill core logging and sampling, digital data entry, collation and interpretation of geological information, geologic mapping, and effective communication with drill contractors and fellow geologists.<\/p>\n<p><strong>Responsibilities:<\/strong><\/p>\n<ol><li>Drill Core Logging and Sampling:<ul><li>Conduct detailed and accurate logging of drill core samples.<\/li><li>Implement best practices for core sampling, ensuring high-quality data collection.<\/li><li>Collaborate with drilling teams to optimize core recovery and maintain data integrity.<\/li><\/ul><\/li><li>Digital Data Entry:<ul><li>Perform timely and precise digital entry of geological information using relevant software.<\/li><li>Organize and manage databases to facilitate efficient data retrieval and analysis.<\/li><li>Maintain a high level of accuracy in data entry to support reliable geological interpretations.<\/li><\/ul><\/li><li>Collation and Interpretation of Data:<ul><li>Analyze geological data to identify patterns, trends, and potential mineralization.<\/li><li>Collaborate with cross-functional teams to integrate geological findings into broader project objectives.<\/li><li>Contribute to the development of geological models and interpretations.<\/li><\/ul><\/li><li>Liaising with Drill Contractors and Other Geologists:<ul><li>Establish and maintain effective communication with drill contractors to ensure project objectives are met.<\/li><li>Collaborate with fellow geologists to share insights, coordinate activities, and enhance overall project understanding.<\/li><li>Provide clear and concise updates to project stakeholders, fostering a collaborative working environment.<\/li><\/ul><\/li><li>Geologic Mapping:<ul><li>Conduct geologic mapping to enhance the understanding of the project area.<\/li><li>Utilize mapping data to contribute to geological models and exploration strategies.<\/li><li>Document and communicate mapping findings to support broader geological interpretations.<\/li><\/ul><\/li><\/ol>\n<p><strong>Qualifications:<\/strong><\/p>\n<ul><li>Bachelor's or higher degree in Geology, Earth Sciences, or a related field.<\/li><li>Proven experience in drill core logging and sampling.<\/li><li>Proficiency in digital data entry and geological software.<\/li><li>Strong analytical and problem-solving skills.<\/li><li>Excellent communication and interpersonal skills.<\/li><li>Ability to work collaboratively in a team and independently in the field.<\/li><li>Familiarity with geologic mapping techniques and tools.<\/li><li>Alaskan-based candidates only.<\/li><\/ul>\n<p>Applicants must be authorized to work for ANY employer in the U.S. We are unable to sponsor or take over sponsorship of an employment Visa at this time.<\/p>","post_title":"Geologist","post_link":"https:\/\/turnerstaffing.com\/position\/geologist-3\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"","%location_country%":"United States","%location_city%":"Fairbanks","%location_state_id%":"AK","%location_state_name%":"Alaska","%location_city_state%":"Fairbanks, AK","%education%":"","%department%":"","%description%":"<p>We are seeking a highly motivated and detail-oriented Core Logging Geologist to join our dynamic team. As a Core Logging Geologist, you will play a crucial role in the exploration and development of mineral resources. This position involves a combination of field and office work, requiring expertise in drill core logging and sampling, digital data entry, collation and interpretation of geological information, geologic mapping, and effective communication with drill contractors and fellow geologists.<\/p>\n<p><strong>Responsibilities:<\/strong><\/p>\n<ol><li>Drill Core Logging and Sampling:<ul><li>Conduct detailed and accurate logging of drill core samples.<\/li><li>Implement best practices for core sampling, ensuring high-quality data collection.<\/li><li>Collaborate with drilling teams to optimize core recovery and maintain data integrity.<\/li><\/ul><\/li><li>Digital Data Entry:<ul><li>Perform timely and precise digital entry of geological information using relevant software.<\/li><li>Organize and manage databases to facilitate efficient data retrieval and analysis.<\/li><li>Maintain a high level of accuracy in data entry to support reliable geological interpretations.<\/li><\/ul><\/li><li>Collation and Interpretation of Data:<ul><li>Analyze geological data to identify patterns, trends, and potential mineralization.<\/li><li>Collaborate with cross-functional teams to integrate geological findings into broader project objectives.<\/li><li>Contribute to the development of geological models and interpretations.<\/li><\/ul><\/li><li>Liaising with Drill Contractors and Other Geologists:<ul><li>Establish and maintain effective communication with drill contractors to ensure project objectives are met.<\/li><li>Collaborate with fellow geologists to share insights, coordinate activities, and enhance overall project understanding.<\/li><li>Provide clear and concise updates to project stakeholders, fostering a collaborative working environment.<\/li><\/ul><\/li><li>Geologic Mapping:<ul><li>Conduct geologic mapping to enhance the understanding of the project area.<\/li><li>Utilize mapping data to contribute to geological models and exploration strategies.<\/li><li>Document and communicate mapping findings to support broader geological interpretations.<\/li><\/ul><\/li><\/ol>\n<p><strong>Qualifications:<\/strong><\/p>\n<ul><li>Bachelor's or higher degree in Geology, Earth Sciences, or a related field.<\/li><li>Proven experience in drill core logging and sampling.<\/li><li>Proficiency in digital data entry and geological software.<\/li><li>Strong analytical and problem-solving skills.<\/li><li>Excellent communication and interpersonal skills.<\/li><li>Ability to work collaboratively in a team and independently in the field.<\/li><li>Familiarity with geologic mapping techniques and tools.<\/li><li>Alaskan-based candidates only.<\/li><\/ul>\n<p>Applicants must be authorized to work for ANY employer in the U.S. We are unable to sponsor or take over sponsorship of an employment Visa at this time.<\/p>","%category%":"","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/c56d4b6af3bf-geologist","%breezy_id%":"c56d4b6af3bf","%breezy_friendly_id%":"c56d4b6af3bf-geologist","%breezy_created_date%":"2024-01-31T17:22:38.562Z","%breezy_updated_date%":"2025-03-20T16:09:04.211Z","%_wpgmp_location_city%":"Fairbanks","%_wpgmp_location_state%":"AK","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Fairbanks, AK, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"64.8400511","%_wpgmp_metabox_longitude%":"-147.7199756","%rank_math_internal_links_processed%":"1"}},"id":2278,"infowindow_disable":false},{"source":"post","title":"Project Manager- Electrical Construction","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Project Manager- Electrical Construction\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Our client is&nbsp;currently seeking a&nbsp;Project Manager for an immediate opening in Cedar Rapids, IA. The Project Manager will be responsible&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/project-manager-electrical-construction\/\" name=\"Project Manager- Electrical Construction\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Our client is&nbsp;currently seeking a&nbsp;Project Manager for an immediate opening in Cedar Rapids, IA. The Project Manager will be responsible&hellip;","address":"Cedar Rapids, IA, USA","location":{"lat":"41.9778795","city":"Cedar Rapids","state":"IA","country":"United States","lng":"-91.6656232","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/project-manager-electrical-construction\/","zoom":19,"extra_fields":{"post_excerpt":"Our client is&nbsp;currently seeking a&nbsp;Project Manager for an immediate opening in Cedar Rapids, IA. The Project Manager will be responsible&hellip;","post_content":"<p>Our client is&nbsp;currently seeking a&nbsp;Project Manager for an immediate opening in Cedar Rapids, IA. The Project Manager will be responsible for preparing detailed estimates for Construction projects.<\/p>\n<p><\/p>\n<p>Responsibilities include but are not limited to:<\/p>\n<ul><li>Providing follow-up regarding the status of quoted items, subcontractors, and equipment purchase orders<\/li><li>attending weekly job meetings (onsite and internally)<\/li><li>Supervising total construction effort to ensure the project is constructed per design, budget, and schedule (includes interfacing with customer representatives, A-E representatives, other contractors, etc.)<\/li><li>Planning, coordinating, and supervising on-site functions (scheduling, engineering, material control, and may provide day-to-day direction of on-site administrative staff in accounting, purchasing, etc.)<\/li><li>Supervising craft employees and\/or other contractors as required by the contract<\/li><li>Providing technical assistance, i.e. interpretation of drawings, recommending construction methods and equipment, etc., as required<\/li><li>Estimating of projects<\/li><li>Directing and assigning manpower<\/li><li>Attaining rental equipment as needed<\/li><li>Estimating and issuance of change orders<\/li><li>Assuming responsibility for productivity of crafts, efficient use of materials and equipment, and contractual performance of the project<\/li><li>Fostering and maintaining good morale and positive relationships with field, customers and\/or office personnel<\/li><li>Participating as a team in calling and selling customers on potential project<\/li><li>Performing additional assignments per management\u2019s direction<\/li><\/ul>\n<p>Qualifications:&nbsp;<\/p>\n<ul><li>5+ years of experience in the Electrical construction industry and previous management experience.<\/li><li>Previous experience in Mission Critical\/hyper-scale projects<\/li><\/ul>","post_title":"Project Manager- Electrical Construction","post_link":"https:\/\/turnerstaffing.com\/position\/project-manager-electrical-construction\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Senior","%location_country%":"United States","%location_city%":"Cedar Rapids","%location_state_id%":"IA","%location_state_name%":"Iowa","%location_city_state%":"Cedar Rapids, IA","%education%":"Bachelor's Degree","%department%":"","%description%":"<p>Our client is&nbsp;currently seeking a&nbsp;Project Manager for an immediate opening in Cedar Rapids, IA. The Project Manager will be responsible for preparing detailed estimates for Construction projects.<\/p>\n<p><\/p>\n<p>Responsibilities include but are not limited to:<\/p>\n<ul><li>Providing follow-up regarding the status of quoted items, subcontractors, and equipment purchase orders<\/li><li>attending weekly job meetings (onsite and internally)<\/li><li>Supervising total construction effort to ensure the project is constructed per design, budget, and schedule (includes interfacing with customer representatives, A-E representatives, other contractors, etc.)<\/li><li>Planning, coordinating, and supervising on-site functions (scheduling, engineering, material control, and may provide day-to-day direction of on-site administrative staff in accounting, purchasing, etc.)<\/li><li>Supervising craft employees and\/or other contractors as required by the contract<\/li><li>Providing technical assistance, i.e. interpretation of drawings, recommending construction methods and equipment, etc., as required<\/li><li>Estimating of projects<\/li><li>Directing and assigning manpower<\/li><li>Attaining rental equipment as needed<\/li><li>Estimating and issuance of change orders<\/li><li>Assuming responsibility for productivity of crafts, efficient use of materials and equipment, and contractual performance of the project<\/li><li>Fostering and maintaining good morale and positive relationships with field, customers and\/or office personnel<\/li><li>Participating as a team in calling and selling customers on potential project<\/li><li>Performing additional assignments per management\u2019s direction<\/li><\/ul>\n<p>Qualifications:&nbsp;<\/p>\n<ul><li>5+ years of experience in the Electrical construction industry and previous management experience.<\/li><li>Previous experience in Mission Critical\/hyper-scale projects<\/li><\/ul>","%category%":"Management","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/b09b84a0d432-project-manager-electrical-construction","%breezy_id%":"b09b84a0d432","%breezy_friendly_id%":"b09b84a0d432-project-manager-electrical-construction","%breezy_created_date%":"2025-03-19T16:15:58.728Z","%breezy_updated_date%":"2025-03-19T16:16:27.782Z","%_wpgmp_location_city%":"Cedar Rapids","%_wpgmp_location_state%":"IA","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Cedar Rapids, IA, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"41.9778795","%_wpgmp_metabox_longitude%":"-91.6656232","%rank_math_internal_links_processed%":"1"}},"id":2274,"infowindow_disable":false},{"source":"post","title":"Lead Pipe Foreman","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Lead Pipe Foreman\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Lead Foreman Construction &amp; Site Development | Charlotte, NC Area Turner Staffing Group is partnered with a construction and site&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/lead-pipe-foreman\/\" name=\"Lead Pipe Foreman\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Lead Foreman Construction &amp; Site Development | Charlotte, NC Area Turner Staffing Group is partnered with a construction and site&hellip;","address":"Charlotte, NC, USA","location":{"lat":"35.2215548","city":"Charlotte","state":"NC","country":"United States","lng":"-80.840116","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/lead-pipe-foreman\/","zoom":19,"extra_fields":{"post_excerpt":"Lead Foreman Construction &amp; Site Development | Charlotte, NC Area Turner Staffing Group is partnered with a construction and site&hellip;","post_content":"<p><strong>Lead Foreman<\/strong><br>\n<em>Construction &amp; Site Development | Charlotte, NC Area<\/em><\/p>\n<p>Turner Staffing Group is partnered with a <strong>construction and site development company<\/strong> seeking a <strong>Lead Foreman<\/strong> to join their team. This individual will be responsible for overseeing daily operations, managing crews, and ensuring projects run smoothly and efficiently.<\/p>\n<h3><strong>Key Responsibilities:<\/strong><\/h3>\n<ul>\n<li>Oversee <strong>day-to-day operations<\/strong> on the jobsite, ensuring tasks are completed efficiently.<\/li>\n<li>Ensure all <strong>necessary tools and equipment<\/strong> are available for daily tasks.<\/li>\n<li><strong>Manage and train<\/strong> new laborers and Heavy Equipment Operators (HEO).<\/li>\n<li>Work closely with the <strong>Superintendent<\/strong> to ensure adequate manpower for each task.<\/li>\n<li>Coordinate with the Superintendent to ensure <strong>materials<\/strong> are available as needed.<\/li>\n<li><strong>Resolve conflicts and troubleshoot problems<\/strong>, escalating to the Superintendent when necessary.<\/li>\n<li><strong>Assign tasks<\/strong> to laborers and HEOs, ensuring workflow efficiency.<\/li>\n<li>Clearly <strong>communicate the daily plan<\/strong> to the labor force, keeping the team aligned with project goals.<\/li>\n<\/ul>\n<h3><strong>Qualifications &amp; Skills:<\/strong><\/h3>\n<ul>\n<li>Proven experience as a <strong>Foreman or similar leadership role<\/strong> in construction or site development.<\/li>\n<li>Strong knowledge of <strong>construction practices, equipment, and safety protocols<\/strong>.<\/li>\n<li>Ability to <strong>train and manage teams<\/strong> effectively.<\/li>\n<li>Strong problem-solving skills and <strong>ability to handle jobsite challenges<\/strong>.<\/li>\n<li>Excellent <strong>communication and coordination skills<\/strong>.<\/li>\n<\/ul>\n<p>This is a great opportunity for a hands-on leader looking to make an impact in <strong>construction and site development<\/strong>.<\/p>","post_title":"Lead Pipe Foreman","post_link":"https:\/\/turnerstaffing.com\/position\/lead-pipe-foreman\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Associate","%location_country%":"United States","%location_city%":"Charlotte","%location_state_id%":"NC","%location_state_name%":"North Carolina","%location_city_state%":"Charlotte, NC","%education%":"Unspecified","%department%":"Operations","%description%":"<p><strong>Lead Foreman<\/strong><br>\n<em>Construction &amp; Site Development | Charlotte, NC Area<\/em><\/p>\n<p>Turner Staffing Group is partnered with a <strong>construction and site development company<\/strong> seeking a <strong>Lead Foreman<\/strong> to join their team. This individual will be responsible for overseeing daily operations, managing crews, and ensuring projects run smoothly and efficiently.<\/p>\n<h3><strong>Key Responsibilities:<\/strong><\/h3>\n<ul>\n<li>Oversee <strong>day-to-day operations<\/strong> on the jobsite, ensuring tasks are completed efficiently.<\/li>\n<li>Ensure all <strong>necessary tools and equipment<\/strong> are available for daily tasks.<\/li>\n<li><strong>Manage and train<\/strong> new laborers and Heavy Equipment Operators (HEO).<\/li>\n<li>Work closely with the <strong>Superintendent<\/strong> to ensure adequate manpower for each task.<\/li>\n<li>Coordinate with the Superintendent to ensure <strong>materials<\/strong> are available as needed.<\/li>\n<li><strong>Resolve conflicts and troubleshoot problems<\/strong>, escalating to the Superintendent when necessary.<\/li>\n<li><strong>Assign tasks<\/strong> to laborers and HEOs, ensuring workflow efficiency.<\/li>\n<li>Clearly <strong>communicate the daily plan<\/strong> to the labor force, keeping the team aligned with project goals.<\/li>\n<\/ul>\n<h3><strong>Qualifications &amp; Skills:<\/strong><\/h3>\n<ul>\n<li>Proven experience as a <strong>Foreman or similar leadership role<\/strong> in construction or site development.<\/li>\n<li>Strong knowledge of <strong>construction practices, equipment, and safety protocols<\/strong>.<\/li>\n<li>Ability to <strong>train and manage teams<\/strong> effectively.<\/li>\n<li>Strong problem-solving skills and <strong>ability to handle jobsite challenges<\/strong>.<\/li>\n<li>Excellent <strong>communication and coordination skills<\/strong>.<\/li>\n<\/ul>\n<p>This is a great opportunity for a hands-on leader looking to make an impact in <strong>construction and site development<\/strong>.<\/p>","%category%":"Operations","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/dd3e32aef9ea-lead-pipe-foreman","%breezy_id%":"dd3e32aef9ea","%breezy_friendly_id%":"dd3e32aef9ea-lead-pipe-foreman","%breezy_created_date%":"2025-03-19T13:51:48.119Z","%breezy_updated_date%":"2025-03-19T13:52:36.820Z","%_wpgmp_location_city%":"Charlotte","%_wpgmp_location_state%":"NC","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Charlotte, NC, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"35.2215548","%_wpgmp_metabox_longitude%":"-80.840116","%rank_math_internal_links_processed%":"1"}},"id":2271,"infowindow_disable":false},{"source":"post","title":"Assistant Project Manager","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Assistant Project Manager\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Our client&nbsp;is currently seeking an Assistant Project Manager\/Project Coordinator for an immediate opening in Cedar Rapids, IA.&nbsp; The Assistant Project&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/assistant-project-manager\/\" name=\"Assistant Project Manager\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Our client&nbsp;is currently seeking an Assistant Project Manager\/Project Coordinator for an immediate opening in Cedar Rapids, IA.&nbsp; The Assistant Project&hellip;","address":"Cedar Rapids, IA, USA","location":{"lat":"41.9778795","city":"Cedar Rapids","state":"IA","country":"United States","lng":"-91.6656232","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/assistant-project-manager\/","zoom":19,"extra_fields":{"post_excerpt":"Our client&nbsp;is currently seeking an Assistant Project Manager\/Project Coordinator for an immediate opening in Cedar Rapids, IA.&nbsp; The Assistant Project&hellip;","post_content":"<p>Our client&nbsp;is currently seeking an Assistant Project Manager\/Project Coordinator for an immediate opening in Cedar Rapids, IA.&nbsp; The Assistant Project Manager will be responsible for providing overall support and assistance to the estimator, project managers, and field personnel.<\/p>\n<p><\/p>\n<p>Responsibilities include but are not limited to:<\/p>\n<ul><li>Attend Preconstruction\/Kick Off Meetings<\/li><li>Attend pre-bid meetings to determine scope of work and required contents of projects<\/li><li>Review proposed specifications and drawings to determine scope of work and required contents of estimate<\/li><li>Assist estimators gathering quotes, printing drawings, counting, take-off estimating, and responding to RFIs and RFQs<\/li><li>Document management, including RFIs, Constraints, Purchase Order Logs, and Change Orders<\/li><li>Professionally interact with customers, other trades, general contractors, and internal staff<\/li><li>Assist with project controls, including schedule and productivity<\/li><li>Assist with the assembly of shop drawings as per project requirements<\/li><li>Provide follow up to project manager regarding status of quoted items, subcontractors, and equipment purchase orders<\/li><li>Prepare clean, full size and half size prints for Project Manager, Superintendents, General Foreman and Foreman<\/li><li>Assist in project close out including submission of warranty information, as-built drawings, and operation and maintenance manuals<\/li><li>Maintain good relationships with customers both internally and externally<\/li><\/ul>\n<p><\/p>\n<p>Qualifications:<\/p>\n<ul><li>Bachelor\u2019s Degree in Engineering, Construction Management or related field, 1-5 years of related experience and\/or the equivalent combination of education and experience.<\/li><li>Previous experience on a construction project is preferred but not required.<\/li><li>A thorough understanding of the Microsoft Office Suite including Microsoft Project is also required.<\/li><\/ul>","post_title":"Assistant Project Manager","post_link":"https:\/\/turnerstaffing.com\/position\/assistant-project-manager\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Mid Level","%location_country%":"United States","%location_city%":"Cedar Rapids","%location_state_id%":"IA","%location_state_name%":"Iowa","%location_city_state%":"Cedar Rapids, IA","%education%":"Bachelor's Degree","%department%":"","%description%":"<p>Our client&nbsp;is currently seeking an Assistant Project Manager\/Project Coordinator for an immediate opening in Cedar Rapids, IA.&nbsp; The Assistant Project Manager will be responsible for providing overall support and assistance to the estimator, project managers, and field personnel.<\/p>\n<p><\/p>\n<p>Responsibilities include but are not limited to:<\/p>\n<ul><li>Attend Preconstruction\/Kick Off Meetings<\/li><li>Attend pre-bid meetings to determine scope of work and required contents of projects<\/li><li>Review proposed specifications and drawings to determine scope of work and required contents of estimate<\/li><li>Assist estimators gathering quotes, printing drawings, counting, take-off estimating, and responding to RFIs and RFQs<\/li><li>Document management, including RFIs, Constraints, Purchase Order Logs, and Change Orders<\/li><li>Professionally interact with customers, other trades, general contractors, and internal staff<\/li><li>Assist with project controls, including schedule and productivity<\/li><li>Assist with the assembly of shop drawings as per project requirements<\/li><li>Provide follow up to project manager regarding status of quoted items, subcontractors, and equipment purchase orders<\/li><li>Prepare clean, full size and half size prints for Project Manager, Superintendents, General Foreman and Foreman<\/li><li>Assist in project close out including submission of warranty information, as-built drawings, and operation and maintenance manuals<\/li><li>Maintain good relationships with customers both internally and externally<\/li><\/ul>\n<p><\/p>\n<p>Qualifications:<\/p>\n<ul><li>Bachelor\u2019s Degree in Engineering, Construction Management or related field, 1-5 years of related experience and\/or the equivalent combination of education and experience.<\/li><li>Previous experience on a construction project is preferred but not required.<\/li><li>A thorough understanding of the Microsoft Office Suite including Microsoft Project is also required.<\/li><\/ul>","%category%":"Management","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/10dacc7b0702-assistant-project-manager","%breezy_id%":"10dacc7b0702","%breezy_friendly_id%":"10dacc7b0702-assistant-project-manager","%breezy_created_date%":"2025-03-19T15:59:05.344Z","%breezy_updated_date%":"2025-03-19T15:59:47.828Z","%_wpgmp_location_city%":"Cedar Rapids","%_wpgmp_location_state%":"IA","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Cedar Rapids, IA, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"41.9778795","%_wpgmp_metabox_longitude%":"-91.6656232","%rank_math_internal_links_processed%":"1"}},"id":2272,"infowindow_disable":false},{"source":"post","title":"Project Engineer","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Project Engineer\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Our client is&nbsp;currently seeking a Project Engineer for an immediate opening in Cedar Rapids, IA. The Project Engineer is responsible&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/project-engineer-2\/\" name=\"Project Engineer\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Our client is&nbsp;currently seeking a Project Engineer for an immediate opening in Cedar Rapids, IA. The Project Engineer is responsible&hellip;","address":"Cedar Rapids, IA, USA","location":{"lat":"41.9778795","city":"Cedar Rapids","state":"IA","country":"United States","lng":"-91.6656232","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/project-engineer-2\/","zoom":19,"extra_fields":{"post_excerpt":"Our client is&nbsp;currently seeking a Project Engineer for an immediate opening in Cedar Rapids, IA. The Project Engineer is responsible&hellip;","post_content":"<p>Our client is&nbsp;currently seeking a Project Engineer for an immediate opening in Cedar Rapids, IA. The Project Engineer is responsible for on-site administrative and technical support on construction project sites.<\/p>\n<p><\/p>\n<p>Responsibilities include but are not limited to:<\/p>\n<ul><li>Complete projects on time, within budget and meet the quality demands of our clients<\/li><li>Assist in research and documentation of the procurement of all major equipment packages<\/li><li>Help with the tracking of progress and adherence of the scope of all sub-contractors to be utilized<\/li><li>Assist in the management (scheduling and receiving direction) of all owners furnished equipment<\/li><li>Assist in the logistics of all major package delivery and storage<\/li><li>Administratively support the tracking and logging of all information required within the Procurement, Quality Assurance, Quality Control, and Commissioning activities under the direction of the Project Manager<\/li><li>Support the Project Manager in all areas including, procurement, purchasing, subcontract and lease agreements, and equipment tracking<\/li><li>Maintain Company presence during project meetings \u2013 Jobsite construction and coordination meetings<\/li><li>Assist in tracking project schedule utilizing Primavera P6 software<\/li><li>Assist in gathering documentation for field testing and owner acceptance<\/li><li>Assist in closeout documents<\/li><li>Assist in tracking and scheduling final punch list items<\/li><li>Assist in scheduling and documenting Owner training<\/li><li>Work with PMAs on submitting proper documentation for projects<\/li><li>Assist in the shop drawing review process<\/li><\/ul>\n<p>Qualifications:<\/p>\n<ul><li>Bachelor\u2019s degree in engineering or construction management<\/li><li>1 or more years of related experience in Construction Administration, Construction management, and\/or related education and experience.<\/li><li>Excellent written and verbal communication skills<\/li><li>Knowledge of Primavera P6 is a plus.<\/li><li>OSHA 30 (preferred) If not certified, willingness to obtain upon hire.<\/li><\/ul>","post_title":"Project Engineer","post_link":"https:\/\/turnerstaffing.com\/position\/project-engineer-2\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Mid Level","%location_country%":"United States","%location_city%":"Cedar Rapids","%location_state_id%":"IA","%location_state_name%":"Iowa","%location_city_state%":"Cedar Rapids, IA","%education%":"Bachelor's Degree","%department%":"","%description%":"<p>Our client is&nbsp;currently seeking a Project Engineer for an immediate opening in Cedar Rapids, IA. The Project Engineer is responsible for on-site administrative and technical support on construction project sites.<\/p>\n<p><\/p>\n<p>Responsibilities include but are not limited to:<\/p>\n<ul><li>Complete projects on time, within budget and meet the quality demands of our clients<\/li><li>Assist in research and documentation of the procurement of all major equipment packages<\/li><li>Help with the tracking of progress and adherence of the scope of all sub-contractors to be utilized<\/li><li>Assist in the management (scheduling and receiving direction) of all owners furnished equipment<\/li><li>Assist in the logistics of all major package delivery and storage<\/li><li>Administratively support the tracking and logging of all information required within the Procurement, Quality Assurance, Quality Control, and Commissioning activities under the direction of the Project Manager<\/li><li>Support the Project Manager in all areas including, procurement, purchasing, subcontract and lease agreements, and equipment tracking<\/li><li>Maintain Company presence during project meetings \u2013 Jobsite construction and coordination meetings<\/li><li>Assist in tracking project schedule utilizing Primavera P6 software<\/li><li>Assist in gathering documentation for field testing and owner acceptance<\/li><li>Assist in closeout documents<\/li><li>Assist in tracking and scheduling final punch list items<\/li><li>Assist in scheduling and documenting Owner training<\/li><li>Work with PMAs on submitting proper documentation for projects<\/li><li>Assist in the shop drawing review process<\/li><\/ul>\n<p>Qualifications:<\/p>\n<ul><li>Bachelor\u2019s degree in engineering or construction management<\/li><li>1 or more years of related experience in Construction Administration, Construction management, and\/or related education and experience.<\/li><li>Excellent written and verbal communication skills<\/li><li>Knowledge of Primavera P6 is a plus.<\/li><li>OSHA 30 (preferred) If not certified, willingness to obtain upon hire.<\/li><\/ul>","%category%":"Operations","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/424ec81bf18e-project-engineer","%breezy_id%":"424ec81bf18e","%breezy_friendly_id%":"424ec81bf18e-project-engineer","%breezy_created_date%":"2025-03-19T16:13:30.852Z","%breezy_updated_date%":"2025-03-19T16:14:09.094Z","%_wpgmp_location_city%":"Cedar Rapids","%_wpgmp_location_state%":"IA","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Cedar Rapids, IA, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"41.9778795","%_wpgmp_metabox_longitude%":"-91.6656232","%rank_math_internal_links_processed%":"1"}},"id":2273,"infowindow_disable":false},{"source":"post","title":"Utility Superintendent","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Utility Superintendent\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Utility Superintendent Charlotte, NC Area Turner Staffing Group is partnered with a construction and development company in the Charlotte, NC&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/utility-superintendent\/\" name=\"Utility Superintendent\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Utility Superintendent Charlotte, NC Area Turner Staffing Group is partnered with a construction and development company in the Charlotte, NC&hellip;","address":"Charlotte, NC, USA","location":{"lat":"35.2215548","city":"Charlotte","state":"NC","country":"United States","lng":"-80.840116","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/utility-superintendent\/","zoom":19,"extra_fields":{"post_excerpt":"Utility Superintendent Charlotte, NC Area Turner Staffing Group is partnered with a construction and development company in the Charlotte, NC&hellip;","post_content":"<p><strong>Utility Superintendent<\/strong><br>\n<em>Charlotte, NC Area<\/em><\/p>\n<p>Turner Staffing Group is partnered with a construction and development company in the Charlotte, NC area seeking a <strong>Utility Superintendent<\/strong> to oversee crews and projects. This individual will play a key role in planning, coordinating, and executing utility infrastructure work while ensuring efficiency, safety, and cost management.<\/p>\n<h3><strong>Key Responsibilities:<\/strong><\/h3>\n<ul>\n<li>Develop and implement <strong>long-term jobsite plans<\/strong> to ensure efficient project execution.<\/li>\n<li>Oversee the <strong>layout of projected work<\/strong>, ensuring accuracy and compliance with project specifications.<\/li>\n<li><strong>Schedule material deliveries<\/strong> as necessary to maintain project timelines.<\/li>\n<li>Attend <strong>pre-construction and planning meetings<\/strong> throughout the project lifecycle.<\/li>\n<li><strong>Manage workforce efficiency<\/strong>, ensuring proper allocation of man-hours and overall jobsite cost control.<\/li>\n<li>Oversee and <strong>manage PDF and CAD files<\/strong>, ensuring accurate documentation and integration with project plans.<\/li>\n<li><strong>Resolve conflicts and issues<\/strong> that arise on-site, maintaining smooth project flow.<\/li>\n<li>Step in as <strong>Foreman when necessary<\/strong>, providing direct leadership and hands-on support.<\/li>\n<\/ul>\n<h3><strong>Qualifications &amp; Skills:<\/strong><\/h3>\n<ul>\n<li>Proven experience as a <strong>Utility Superintendent<\/strong> or in a similar supervisory role within <strong>construction or infrastructure development<\/strong>.<\/li>\n<li>Strong knowledge of <strong>utility installation, site layout, and project scheduling<\/strong>.<\/li>\n<li>Proficiency in <strong>reading and managing CAD and PDF files<\/strong> related to construction projects.<\/li>\n<li>Excellent problem-solving skills and ability to handle on-site <strong>conflicts<\/strong> effectively.<\/li>\n<li>Strong communication and leadership abilities, capable of <strong>coordinating multiple teams<\/strong>.<\/li>\n<li>Experience with <strong>budget management and cost control<\/strong>.<\/li>\n<\/ul>\n<p>This role is a great opportunity for a motivated leader to oversee <strong>essential utility projects<\/strong> in the Charlotte, NC area while ensuring quality and efficiency.<\/p>","post_title":"Utility Superintendent","post_link":"https:\/\/turnerstaffing.com\/position\/utility-superintendent\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Associate","%location_country%":"United States","%location_city%":"Charlotte","%location_state_id%":"NC","%location_state_name%":"North Carolina","%location_city_state%":"Charlotte, NC","%education%":"Unspecified","%department%":"Operations","%description%":"<p><strong>Utility Superintendent<\/strong><br>\n<em>Charlotte, NC Area<\/em><\/p>\n<p>Turner Staffing Group is partnered with a construction and development company in the Charlotte, NC area seeking a <strong>Utility Superintendent<\/strong> to oversee crews and projects. This individual will play a key role in planning, coordinating, and executing utility infrastructure work while ensuring efficiency, safety, and cost management.<\/p>\n<h3><strong>Key Responsibilities:<\/strong><\/h3>\n<ul>\n<li>Develop and implement <strong>long-term jobsite plans<\/strong> to ensure efficient project execution.<\/li>\n<li>Oversee the <strong>layout of projected work<\/strong>, ensuring accuracy and compliance with project specifications.<\/li>\n<li><strong>Schedule material deliveries<\/strong> as necessary to maintain project timelines.<\/li>\n<li>Attend <strong>pre-construction and planning meetings<\/strong> throughout the project lifecycle.<\/li>\n<li><strong>Manage workforce efficiency<\/strong>, ensuring proper allocation of man-hours and overall jobsite cost control.<\/li>\n<li>Oversee and <strong>manage PDF and CAD files<\/strong>, ensuring accurate documentation and integration with project plans.<\/li>\n<li><strong>Resolve conflicts and issues<\/strong> that arise on-site, maintaining smooth project flow.<\/li>\n<li>Step in as <strong>Foreman when necessary<\/strong>, providing direct leadership and hands-on support.<\/li>\n<\/ul>\n<h3><strong>Qualifications &amp; Skills:<\/strong><\/h3>\n<ul>\n<li>Proven experience as a <strong>Utility Superintendent<\/strong> or in a similar supervisory role within <strong>construction or infrastructure development<\/strong>.<\/li>\n<li>Strong knowledge of <strong>utility installation, site layout, and project scheduling<\/strong>.<\/li>\n<li>Proficiency in <strong>reading and managing CAD and PDF files<\/strong> related to construction projects.<\/li>\n<li>Excellent problem-solving skills and ability to handle on-site <strong>conflicts<\/strong> effectively.<\/li>\n<li>Strong communication and leadership abilities, capable of <strong>coordinating multiple teams<\/strong>.<\/li>\n<li>Experience with <strong>budget management and cost control<\/strong>.<\/li>\n<\/ul>\n<p>This role is a great opportunity for a motivated leader to oversee <strong>essential utility projects<\/strong> in the Charlotte, NC area while ensuring quality and efficiency.<\/p>","%category%":"Operations","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/6b68fb1bd42e-utility-superintendent","%breezy_id%":"6b68fb1bd42e","%breezy_friendly_id%":"6b68fb1bd42e-utility-superintendent","%breezy_created_date%":"2025-03-19T13:44:56.855Z","%breezy_updated_date%":"2025-03-19T13:45:53.623Z","%_wpgmp_location_city%":"Charlotte","%_wpgmp_location_state%":"NC","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Charlotte, NC, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"35.2215548","%_wpgmp_metabox_longitude%":"-80.840116","%rank_math_internal_links_processed%":"1"}},"id":2270,"infowindow_disable":false},{"source":"post","title":"Operations Superintendent","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Operations Superintendent\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Turner Mining Group &#8211; Project Superintendent We are looking for a dynamic and talented mining industry leader to fill a&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/operations-superintendent-2\/\" name=\"Operations Superintendent\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Turner Mining Group &#8211; Project Superintendent We are looking for a dynamic and talented mining industry leader to fill a&hellip;","address":"Kermit, TX, USA","location":{"lat":"31.8576265","city":"Kermit","state":"TX","country":"United States","lng":"-103.0926652","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/operations-superintendent-2\/","zoom":19,"extra_fields":{"post_excerpt":"Turner Mining Group &#8211; Project Superintendent We are looking for a dynamic and talented mining industry leader to fill a&hellip;","post_content":"<p><strong><u>Turner Mining Group - Project Superintendent <\/u><\/strong><br><\/p>\n\n<p>We are looking for a dynamic and talented mining industry leader to fill a Project Superintendent role at our fast-growing, forward thinking mining services company.<\/p>\n<p>Turner Mining Group is seeking an energetic mining professional who can leverage their mining industry experience to expand upon our fast-growing business, creating best practices for operations management and scalable business processes to ensure profitable projects. <\/p>\n<p>This person will function as a Project Superintendent, overseeing mining operations, work directly with the Senior Vice President of Mining, develop and mentor on-site management, and coordinating with home-office team. Leadership and an ability to problem solve while ensuring mining operations remain on budget and ahead of schedule. This is an opportunity to work as part of the executive leadership team in a fast-paced and flexible environment.<\/p>\n<p><strong>You<\/strong><\/p>\n<p>You want to work for a services company that is rapidly changing the way the largest mining producers do business. You are motivated by solving problems and partnering with our clients and suppliers. You want to work with great people and enjoy being a part of a strong team. You are a seasoned mining leader who is not afraid to jump into every detail. You want to be in a place where continuous learning and growth is the norm. You are adaptable and able to juggle multiple initiatives concurrently.<\/p>\n<p><strong>Position Overview<\/strong><\/p>\n<p>The Project Superintendent primary responsibility is to oversee mining operations within Turner Mining Group. This will include managing the operational and financial performance of projects, implementing processes to ensure effective personnel growth, equipment readiness, client interactions and problem solving and implementing systems and tools to increase efficiency and ensure profitability. Position reports directly to the Director of Operations.<\/p>\n<p><strong>Key Responsibilities<\/strong><\/p>\n<ul><li>Conduct field personnel development by training and monitoring: Equipment operators, maintenance technicians, grade staking, GPS utilization, foremen\u2019s, etc.<\/li><li>Ownership for project budget, profitability, and cost control<\/li><li>Identify, assist with develop, and understand the key financial and operational metrics for success<\/li><li>Oversee operations for safety and compliance<\/li><li>Developing and leading fields teams to increase performance<\/li><li>Implement business division reporting and metrics reviews<\/li><li>Coordinate site needs, crews for scheduling, planning, and resources<\/li><li>Monitor forward-looking personnel requirements and vendor developments<\/li><li>Negotiate and manage client and vendor relationships<\/li><li>Approve appropriate invoices and proposal submissions<\/li><li>Assist Biz Dev &amp; Estimation Team with Pre-Bid site visits, analysis, and work plans for project proposals<\/li><\/ul>\n<p><strong>Essential Skills &amp; Knowledge<\/strong><\/p>\n<ul><li>Detailed understanding of civil and mining operations<\/li><li>General understanding of business leadership<\/li><li>Ability to oversee operational and organizational performance for mining projects<\/li><li>Solid understanding of financial and operational reporting<\/li><li>Ability to quantify and explain variances to owners and executives succinctly and clearly<\/li><li>Proficiency in civil and mining best practices to perform project management<\/li><li>Intelligent with demonstrated results from creativity<\/li><li>Willingness to learn what is takes to run growing and successful teams<\/li><li>Strong organizational, interpersonal, and written communication skill<\/li><li>Gifted person who can prioritize and balance competing initiatives and activities<\/li><li>Knack for continuous improvement of processes, solution-based issue resolution and outcomes<\/li><li>Organized, problem solver and solution developer, who can work with workers, engineers and owner teams<\/li><li>Believe in the power of culture with strong leadership qualities<\/li><\/ul>\n<p><strong>Benefits<\/strong><\/p>\n<p>Turner Mining Group offers a competitive salary, an excellent work culture, career advancement opportunities. Our team offers a benefits program which includes Medical, Dental, Vision, Life, and a 401k with company match. We believe in a work life balance and established a Paid Time Off policy as well as paid time off for major holidays.<\/p>\n<p>At Turner Mining Group, we encourage and celebrate an inclusive environment for all employees and are proud to be an equal opportunity workplace and affirmative action employer.<\/p>","post_title":"Operations Superintendent","post_link":"https:\/\/turnerstaffing.com\/position\/operations-superintendent-2\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Mid Level","%location_country%":"United States","%location_city%":"Kermit","%location_state_id%":"TX","%location_state_name%":"Texas","%location_city_state%":"Kermit, TX","%education%":"Unspecified","%department%":"Operations","%description%":"<p><strong><u>Turner Mining Group - Project Superintendent <\/u><\/strong><br><\/p>\n\n<p>We are looking for a dynamic and talented mining industry leader to fill a Project Superintendent role at our fast-growing, forward thinking mining services company.<\/p>\n<p>Turner Mining Group is seeking an energetic mining professional who can leverage their mining industry experience to expand upon our fast-growing business, creating best practices for operations management and scalable business processes to ensure profitable projects. <\/p>\n<p>This person will function as a Project Superintendent, overseeing mining operations, work directly with the Senior Vice President of Mining, develop and mentor on-site management, and coordinating with home-office team. Leadership and an ability to problem solve while ensuring mining operations remain on budget and ahead of schedule. This is an opportunity to work as part of the executive leadership team in a fast-paced and flexible environment.<\/p>\n<p><strong>You<\/strong><\/p>\n<p>You want to work for a services company that is rapidly changing the way the largest mining producers do business. You are motivated by solving problems and partnering with our clients and suppliers. You want to work with great people and enjoy being a part of a strong team. You are a seasoned mining leader who is not afraid to jump into every detail. You want to be in a place where continuous learning and growth is the norm. You are adaptable and able to juggle multiple initiatives concurrently.<\/p>\n<p><strong>Position Overview<\/strong><\/p>\n<p>The Project Superintendent primary responsibility is to oversee mining operations within Turner Mining Group. This will include managing the operational and financial performance of projects, implementing processes to ensure effective personnel growth, equipment readiness, client interactions and problem solving and implementing systems and tools to increase efficiency and ensure profitability. Position reports directly to the Director of Operations.<\/p>\n<p><strong>Key Responsibilities<\/strong><\/p>\n<ul><li>Conduct field personnel development by training and monitoring: Equipment operators, maintenance technicians, grade staking, GPS utilization, foremen\u2019s, etc.<\/li><li>Ownership for project budget, profitability, and cost control<\/li><li>Identify, assist with develop, and understand the key financial and operational metrics for success<\/li><li>Oversee operations for safety and compliance<\/li><li>Developing and leading fields teams to increase performance<\/li><li>Implement business division reporting and metrics reviews<\/li><li>Coordinate site needs, crews for scheduling, planning, and resources<\/li><li>Monitor forward-looking personnel requirements and vendor developments<\/li><li>Negotiate and manage client and vendor relationships<\/li><li>Approve appropriate invoices and proposal submissions<\/li><li>Assist Biz Dev &amp; Estimation Team with Pre-Bid site visits, analysis, and work plans for project proposals<\/li><\/ul>\n<p><strong>Essential Skills &amp; Knowledge<\/strong><\/p>\n<ul><li>Detailed understanding of civil and mining operations<\/li><li>General understanding of business leadership<\/li><li>Ability to oversee operational and organizational performance for mining projects<\/li><li>Solid understanding of financial and operational reporting<\/li><li>Ability to quantify and explain variances to owners and executives succinctly and clearly<\/li><li>Proficiency in civil and mining best practices to perform project management<\/li><li>Intelligent with demonstrated results from creativity<\/li><li>Willingness to learn what is takes to run growing and successful teams<\/li><li>Strong organizational, interpersonal, and written communication skill<\/li><li>Gifted person who can prioritize and balance competing initiatives and activities<\/li><li>Knack for continuous improvement of processes, solution-based issue resolution and outcomes<\/li><li>Organized, problem solver and solution developer, who can work with workers, engineers and owner teams<\/li><li>Believe in the power of culture with strong leadership qualities<\/li><\/ul>\n<p><strong>Benefits<\/strong><\/p>\n<p>Turner Mining Group offers a competitive salary, an excellent work culture, career advancement opportunities. Our team offers a benefits program which includes Medical, Dental, Vision, Life, and a 401k with company match. We believe in a work life balance and established a Paid Time Off policy as well as paid time off for major holidays.<\/p>\n<p>At Turner Mining Group, we encourage and celebrate an inclusive environment for all employees and are proud to be an equal opportunity workplace and affirmative action employer.<\/p>","%category%":"Operations","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/429732427df7-operations-superintendent","%breezy_id%":"429732427df7","%breezy_friendly_id%":"429732427df7-operations-superintendent","%breezy_created_date%":"2024-12-11T15:33:05.832Z","%breezy_updated_date%":"2025-03-17T17:09:10.542Z","%_wpgmp_location_city%":"Kermit","%_wpgmp_location_state%":"TX","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Kermit, TX, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"31.8576265","%_wpgmp_metabox_longitude%":"-103.0926652","%rank_math_internal_links_processed%":"1"}},"id":2263,"infowindow_disable":false},{"source":"post","title":"Equipment Superintendent &#8211; Mining","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Equipment Superintendent &#8211; Mining\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Equipment Superintendent Job Description Manage Project maintenance and Equipment Vendor personnel Reports to Project Manager Safety Leadership Invest, teach, and&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/equipment-superintendent-mining\/\" name=\"Equipment Superintendent &#8211; Mining\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Equipment Superintendent Job Description Manage Project maintenance and Equipment Vendor personnel Reports to Project Manager Safety Leadership Invest, teach, and&hellip;","address":"Kermit, TX, USA","location":{"lat":"31.8576265","city":"Kermit","state":"TX","country":"United States","lng":"-103.0926652","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/equipment-superintendent-mining\/","zoom":19,"extra_fields":{"post_excerpt":"Equipment Superintendent Job Description Manage Project maintenance and Equipment Vendor personnel Reports to Project Manager Safety Leadership Invest, teach, and&hellip;","post_content":"<p><strong>Equipment Superintendent Job Description<\/strong><\/p>\n<p><strong>Manage Project maintenance and Equipment Vendor personnel<\/strong><\/p>\n<p><strong>Reports to Project Manager<\/strong><\/p>\n<p><strong><u>Safety Leadership<\/u><\/strong><\/p>\n<ul><li>Invest, teach, and mentor project maintenance personnel to foster \"An Eye For Safety\u201d environment at the site<\/li><li>Mitigate onsite safety risks<\/li><li>Ensure all MSHA regulations are followed and maintain site safety standards<\/li><li>Conduct and participate in monthly site safety meetings to discuss incidents, safety trends, behavior goals, etc.<\/li><li>Ensure all workplace exams are complete and accurate<\/li><li>Task training is completed correctly and stored<\/li><li>Pre-operational inspection issues are corrected, and forms are filed according to the TMG process<\/li><li>All safety documents are filed and stored on-site<\/li><li>Follow the TMG process for incident investigation and response<\/li><li>Complete incident report in HCSS Safety<\/li><li>Provide employees with a safe and healthy work environment by providing safe systems of work, safe work procedures, adequate training and instruction, and competent supervision<\/li><li>Review hazard identification, near miss, and incident reports and provide follow-up as appropriate<\/li><li>Ensure maintenance employees and contractors working within the Site Project personnel are prequalified and have the necessary commencement paperwork, competencies, and qualifications to work safely and deliver quality maintenance services (has Stop Work Authority if standards are not met)<\/li><\/ul>\n<p><strong><u>Major Responsibilities<\/u><\/strong><\/p>\n<ul><li>Spend considerable time in the field interacting with the workforce \u2013 Creating&nbsp;<strong>\u201cvisible felt leadership\u201d<\/strong>&nbsp;~25 to 40% of working time<\/li><li>TMG fuel and lube technicians will report to the role<\/li><li>Manager equipment vendor maintenance personnel and coordinate their site activities<\/li><li>Develop systems and foster the required collaboration to ensure the department meets monthly targets<\/li><li>Review competencies, Scopes of Work, and Schedules of Rates for all Contractors, ensuring costs are managed and controlled while complying with Contractor Controls Policies and Procedures<\/li><li>Help develop maintenance strategy objectives and ensure they are met<\/li><li>Improve Equipment\/Operations Performance by Optimize Equipment &amp; Fleet Asset Reliability<\/li><li>Ensure the effective and efficient application of maintenance resources, as measured by schedule compliance, PM compliance, the level of planned vs. unplanned work, and the ongoing management of backlog<\/li><li>Create service requests, work orders, and purchase orders for repairs\/purchases in the TMG accounting systems and communicating with vendors during the purchase process<\/li><li>Assist Project Manager as needed with tracking maintenance costs and accounting<\/li><li>Participate in incident investigations (injury, high-potential, and equipment damage) to ensure that corrective actions are effectively implemented and tracked<\/li><li>Support the development and ongoing optimization of maintenance strategies for critical assets.<\/li><li>Complete performance evaluation reviews for direct reports and manage their career development.<\/li><li>Recruit for Maintenance positions. Ensure that succession planning for critical roles is in place<\/li><li>Ensure applicable maintenance training is provided as required<\/li><li>Communicate daily needs with Project team<\/li><li>Manage equipment costs, repairs, rebuilds, warrantee items, and equipment replacements<\/li><li>Manage field services for operations: service and mechanics trucks, tools, etc.<\/li><li>These responsibilities are required but not limited to and others may be assigned by the Project Manager as needed<\/li><\/ul>\n<p>Develop an equipment coordinator position if the need arises in the future<\/p>\n<p><\/p>\n<p><strong><u>Preferred Candidate Requirements:<\/u><\/strong><\/p>\n<ul><li>Minimum 5-7 years Maintenance General Foreman level or higher experience in heavy industry<\/li><li>Minimum of 4 years of management of the maintenance scheduling and workflow function<\/li><\/ul>\n<p><strong><u>Personnel Management<\/u><\/strong><\/p>\n<p>\u2022 Submit hiring requests\/termination requisitions to HR following the TMG process<\/p>\n<p>\u2022     Conduct interviews for maintenance employees<\/p>\n<p>\u2022&nbsp;&nbsp;&nbsp;&nbsp; Complete employee reviews using the TMG form and submit them for approval<\/p>\n<p>\u2022&nbsp;&nbsp;&nbsp;&nbsp; Evaluate maintenance personnel performance<\/p>\n<p>\u2022&nbsp;&nbsp;&nbsp;&nbsp; Document employee issues\/ disciplinary action, send to Project Manager and HR<\/p>\n<p>\u2022&nbsp;&nbsp;&nbsp;&nbsp; Maintain complete knowledge of the employee handbook<\/p>\n<p><strong><u>Benefits<\/u><\/strong><\/p>\n<p>Turner Mining Group offers a competitive salary, an excellent work culture, and career advancement opportunities. Our team provides a benefits program which includes Medical, Dental, Vision, Life, and a 401k with company match.&nbsp; We believe in a work-life balance and have established paid time off for major holidays.<\/p>\n<p>At Turner Mining Group, we encourage and celebrate an inclusive environment for all employees and are proud to be an equal opportunity workplace and affirmative action employer<\/p>","post_title":"Equipment Superintendent &#8211; Mining","post_link":"https:\/\/turnerstaffing.com\/position\/equipment-superintendent-mining\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"","%location_country%":"United States","%location_city%":"Kermit","%location_state_id%":"TX","%location_state_name%":"Texas","%location_city_state%":"Kermit, TX","%education%":"","%department%":"","%description%":"<p><strong>Equipment Superintendent Job Description<\/strong><\/p>\n<p><strong>Manage Project maintenance and Equipment Vendor personnel<\/strong><\/p>\n<p><strong>Reports to Project Manager<\/strong><\/p>\n<p><strong><u>Safety Leadership<\/u><\/strong><\/p>\n<ul><li>Invest, teach, and mentor project maintenance personnel to foster \"An Eye For Safety\u201d environment at the site<\/li><li>Mitigate onsite safety risks<\/li><li>Ensure all MSHA regulations are followed and maintain site safety standards<\/li><li>Conduct and participate in monthly site safety meetings to discuss incidents, safety trends, behavior goals, etc.<\/li><li>Ensure all workplace exams are complete and accurate<\/li><li>Task training is completed correctly and stored<\/li><li>Pre-operational inspection issues are corrected, and forms are filed according to the TMG process<\/li><li>All safety documents are filed and stored on-site<\/li><li>Follow the TMG process for incident investigation and response<\/li><li>Complete incident report in HCSS Safety<\/li><li>Provide employees with a safe and healthy work environment by providing safe systems of work, safe work procedures, adequate training and instruction, and competent supervision<\/li><li>Review hazard identification, near miss, and incident reports and provide follow-up as appropriate<\/li><li>Ensure maintenance employees and contractors working within the Site Project personnel are prequalified and have the necessary commencement paperwork, competencies, and qualifications to work safely and deliver quality maintenance services (has Stop Work Authority if standards are not met)<\/li><\/ul>\n<p><strong><u>Major Responsibilities<\/u><\/strong><\/p>\n<ul><li>Spend considerable time in the field interacting with the workforce \u2013 Creating&nbsp;<strong>\u201cvisible felt leadership\u201d<\/strong>&nbsp;~25 to 40% of working time<\/li><li>TMG fuel and lube technicians will report to the role<\/li><li>Manager equipment vendor maintenance personnel and coordinate their site activities<\/li><li>Develop systems and foster the required collaboration to ensure the department meets monthly targets<\/li><li>Review competencies, Scopes of Work, and Schedules of Rates for all Contractors, ensuring costs are managed and controlled while complying with Contractor Controls Policies and Procedures<\/li><li>Help develop maintenance strategy objectives and ensure they are met<\/li><li>Improve Equipment\/Operations Performance by Optimize Equipment &amp; Fleet Asset Reliability<\/li><li>Ensure the effective and efficient application of maintenance resources, as measured by schedule compliance, PM compliance, the level of planned vs. unplanned work, and the ongoing management of backlog<\/li><li>Create service requests, work orders, and purchase orders for repairs\/purchases in the TMG accounting systems and communicating with vendors during the purchase process<\/li><li>Assist Project Manager as needed with tracking maintenance costs and accounting<\/li><li>Participate in incident investigations (injury, high-potential, and equipment damage) to ensure that corrective actions are effectively implemented and tracked<\/li><li>Support the development and ongoing optimization of maintenance strategies for critical assets.<\/li><li>Complete performance evaluation reviews for direct reports and manage their career development.<\/li><li>Recruit for Maintenance positions. Ensure that succession planning for critical roles is in place<\/li><li>Ensure applicable maintenance training is provided as required<\/li><li>Communicate daily needs with Project team<\/li><li>Manage equipment costs, repairs, rebuilds, warrantee items, and equipment replacements<\/li><li>Manage field services for operations: service and mechanics trucks, tools, etc.<\/li><li>These responsibilities are required but not limited to and others may be assigned by the Project Manager as needed<\/li><\/ul>\n<p>Develop an equipment coordinator position if the need arises in the future<\/p>\n<p><\/p>\n<p><strong><u>Preferred Candidate Requirements:<\/u><\/strong><\/p>\n<ul><li>Minimum 5-7 years Maintenance General Foreman level or higher experience in heavy industry<\/li><li>Minimum of 4 years of management of the maintenance scheduling and workflow function<\/li><\/ul>\n<p><strong><u>Personnel Management<\/u><\/strong><\/p>\n<p>\u2022 Submit hiring requests\/termination requisitions to HR following the TMG process<\/p>\n<p>\u2022     Conduct interviews for maintenance employees<\/p>\n<p>\u2022&nbsp;&nbsp;&nbsp;&nbsp; Complete employee reviews using the TMG form and submit them for approval<\/p>\n<p>\u2022&nbsp;&nbsp;&nbsp;&nbsp; Evaluate maintenance personnel performance<\/p>\n<p>\u2022&nbsp;&nbsp;&nbsp;&nbsp; Document employee issues\/ disciplinary action, send to Project Manager and HR<\/p>\n<p>\u2022&nbsp;&nbsp;&nbsp;&nbsp; Maintain complete knowledge of the employee handbook<\/p>\n<p><strong><u>Benefits<\/u><\/strong><\/p>\n<p>Turner Mining Group offers a competitive salary, an excellent work culture, and career advancement opportunities. Our team provides a benefits program which includes Medical, Dental, Vision, Life, and a 401k with company match.&nbsp; We believe in a work-life balance and have established paid time off for major holidays.<\/p>\n<p>At Turner Mining Group, we encourage and celebrate an inclusive environment for all employees and are proud to be an equal opportunity workplace and affirmative action employer<\/p>","%category%":"Operations","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/53014a57f4f6-equipment-superintendent-mining","%breezy_id%":"53014a57f4f6","%breezy_friendly_id%":"53014a57f4f6-equipment-superintendent-mining","%breezy_created_date%":"2022-10-04T21:05:22.026Z","%breezy_updated_date%":"2025-03-13T18:40:24.937Z","%_wpgmp_location_city%":"Kermit","%_wpgmp_location_state%":"TX","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Kermit, TX, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"31.8576265","%_wpgmp_metabox_longitude%":"-103.0926652","%rank_math_internal_links_processed%":"1"}},"id":2250,"infowindow_disable":false},{"source":"post","title":"Senior Project Manager- Civil Construction","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Senior Project Manager- Civil Construction\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Company Overview: Our client is one of the leading and fastest growing civil contractors in the Tampa Bay area. Their&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/senior-project-manager-civil-construction\/\" name=\"Senior Project Manager- Civil Construction\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Company Overview: Our client is one of the leading and fastest growing civil contractors in the Tampa Bay area. Their&hellip;","address":"Tampa, FL, USA","location":{"lat":"27.9516896","city":"Tampa","state":"FL","country":"United States","lng":"-82.4587527","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/senior-project-manager-civil-construction\/","zoom":19,"extra_fields":{"post_excerpt":"Company Overview: Our client is one of the leading and fastest growing civil contractors in the Tampa Bay area. Their&hellip;","post_content":"<p><strong>Company Overview:<\/strong> Our client is one of the leading and fastest growing civil contractors in the Tampa Bay area. Their mission is to develop lasting relationships with our clients and team members, by creating quality infrastructure project for our communities. They strive to push themselves both from a technological and innovation perspective, as well as striving to be the best team they can!<\/p>\n<p><strong>Why Join Us?<\/strong> Our client&nbsp;offers:<\/p>\n<ul><li>A fast-paced dynamic and inclusive work environment.<\/li><li>Quarterly bonus structure<\/li><li>6% full match for your 401k and other benefits<\/li><li>Immense opportunities for growth and professional development.<\/li><li>In house gym and golf Simulator<\/li><li>Cost effective $20\/$40\/$60\/week individual healthcare plans available.<\/li><li>A new training facility in office, including a construction equipment simulator.<\/li><\/ul>\n<p><strong>What We\u2019re Looking For:<\/strong> To excel in this position, you should bring:<\/p>\n<ul><li>A minimum of 5 years of experience in civil project management.<\/li><li>A dynamic and energetic mindset geared towards collaboration.<\/li><li>The willingness to teach and learn every day.<\/li><li>Exceptional organizational skills and basic to intermediate software skills (Office\/HCSS).<\/li><li>Preferred: A degree in construction management or engineering.<\/li><\/ul>\n<p><strong>About the Role:<\/strong> Are you ready to change the game and join an incredible team? As a Project Manager, you will:<\/p>\n<ul><li>Develop comprehensive project plans, including timelines, resource allocations and procurement strategies.<\/li><li>Coordinate and oversee construction activities, ensuring adherence to project schedules and specifications.<\/li><li>Evaluate and select contractors and subcontractors based on qualifications, experience and cost-effectiveness.<\/li><li>Monitor project progress, track key performance indicators (KPIs) and report on project status to stakeholders.<\/li><li>Ensure compliance with safety regulations and legal requirements, prioritizing a safe working environment for all involved.<\/li><li>Manage construction project documentation, including contracts, permits, drawings and change orders.<\/li><li>Conduct regular meetings to facilitate communication, address challenges and to meet project objectives.<\/li><li>Provide regular updates and reports on project status, including milestones, budget updates, and any significant developments or risks.<\/li><li>Implement and enforce safety protocols and ensure compliance with local building codes and regulations.<\/li><li>Carry out thorough project evaluations and assessments to identify areas for improvement and implement necessary corrective measures.<\/li><li>Provide leadership and guidance to the project team, fostering a collaborative and high-performance work environment.<\/li><\/ul>","post_title":"Senior Project Manager- Civil Construction","post_link":"https:\/\/turnerstaffing.com\/position\/senior-project-manager-civil-construction\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Senior","%location_country%":"United States","%location_city%":"Tampa","%location_state_id%":"FL","%location_state_name%":"Florida","%location_city_state%":"Tampa, FL","%education%":"Bachelor's Degree","%department%":"","%description%":"<p><strong>Company Overview:<\/strong> Our client is one of the leading and fastest growing civil contractors in the Tampa Bay area. Their mission is to develop lasting relationships with our clients and team members, by creating quality infrastructure project for our communities. They strive to push themselves both from a technological and innovation perspective, as well as striving to be the best team they can!<\/p>\n<p><strong>Why Join Us?<\/strong> Our client&nbsp;offers:<\/p>\n<ul><li>A fast-paced dynamic and inclusive work environment.<\/li><li>Quarterly bonus structure<\/li><li>6% full match for your 401k and other benefits<\/li><li>Immense opportunities for growth and professional development.<\/li><li>In house gym and golf Simulator<\/li><li>Cost effective $20\/$40\/$60\/week individual healthcare plans available.<\/li><li>A new training facility in office, including a construction equipment simulator.<\/li><\/ul>\n<p><strong>What We\u2019re Looking For:<\/strong> To excel in this position, you should bring:<\/p>\n<ul><li>A minimum of 5 years of experience in civil project management.<\/li><li>A dynamic and energetic mindset geared towards collaboration.<\/li><li>The willingness to teach and learn every day.<\/li><li>Exceptional organizational skills and basic to intermediate software skills (Office\/HCSS).<\/li><li>Preferred: A degree in construction management or engineering.<\/li><\/ul>\n<p><strong>About the Role:<\/strong> Are you ready to change the game and join an incredible team? As a Project Manager, you will:<\/p>\n<ul><li>Develop comprehensive project plans, including timelines, resource allocations and procurement strategies.<\/li><li>Coordinate and oversee construction activities, ensuring adherence to project schedules and specifications.<\/li><li>Evaluate and select contractors and subcontractors based on qualifications, experience and cost-effectiveness.<\/li><li>Monitor project progress, track key performance indicators (KPIs) and report on project status to stakeholders.<\/li><li>Ensure compliance with safety regulations and legal requirements, prioritizing a safe working environment for all involved.<\/li><li>Manage construction project documentation, including contracts, permits, drawings and change orders.<\/li><li>Conduct regular meetings to facilitate communication, address challenges and to meet project objectives.<\/li><li>Provide regular updates and reports on project status, including milestones, budget updates, and any significant developments or risks.<\/li><li>Implement and enforce safety protocols and ensure compliance with local building codes and regulations.<\/li><li>Carry out thorough project evaluations and assessments to identify areas for improvement and implement necessary corrective measures.<\/li><li>Provide leadership and guidance to the project team, fostering a collaborative and high-performance work environment.<\/li><\/ul>","%category%":"Management","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/c542ea81e162-senior-project-manager-civil-construction","%breezy_id%":"c542ea81e162","%breezy_friendly_id%":"c542ea81e162-senior-project-manager-civil-construction","%breezy_created_date%":"2025-03-12T12:28:21.580Z","%breezy_updated_date%":"2025-03-12T12:30:02.163Z","%_wpgmp_location_city%":"Tampa","%_wpgmp_location_state%":"FL","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Tampa, FL, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"27.9516896","%_wpgmp_metabox_longitude%":"-82.4587527","%rank_math_internal_links_processed%":"1"}},"id":2249,"infowindow_disable":false},{"source":"post","title":"Field Services Technician","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Field Services Technician\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    POSITION SUMMARY: The Field Service Technician will be responsible for providing field support for customer accounts in the South-Central USA&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/field-services-technician\/\" name=\"Field Services Technician\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"POSITION SUMMARY: The Field Service Technician will be responsible for providing field support for customer accounts in the South-Central USA&hellip;","address":"Dallas, TX, USA","location":{"lat":"32.7766642","city":"Dallas","state":"TX","country":"United States","lng":"-96.7969879","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/field-services-technician\/","zoom":19,"extra_fields":{"post_excerpt":"POSITION SUMMARY: The Field Service Technician will be responsible for providing field support for customer accounts in the South-Central USA&hellip;","post_content":"<p><strong><u>POSITION SUMMARY:<\/u><\/strong><\/p>\n<p>The Field Service Technician will be responsible for providing field support for customer accounts in the South-Central USA region, based out of Dallas\/Fort Worth, TX. The role involves troubleshooting mechanical, electrical, and plumbing system issues, as well as documenting and tracking work hours and project-related costs. The technician will collaborate with skilled trades, contractors, engineers, sales teams, purchasing, accounting, and other resources to ensure excellent service for customer accounts within the assigned territory.<\/p>\n<p><strong><u>ESSENTIAL DUTIES AND RESPONSIBILITIES<\/u><\/strong>:<\/p>\n<p>Formal training in Mechanical, Electrical, Engineering disciplines, or related construction trades. Bachelor's degree is preferred.<\/p>\n<p>5-7 years of prior experience in preventative\/predictive maintenance with industrial mechanical or fluid handling\/pumping systems. A basic understanding of fabrication, metals, welding, project estimation, electrical controls, and mechanical systems in an industrial environment is essential. Strong foundational troubleshooting and technical problem-solving skills are required.<\/p>\n<p>Advanced computer skills, ability to work with web-based systems.<\/p>\n<p>Ability to work independently to achieve assigned tasks<\/p>\n<p>Excellent customer service, time management and personal organizational skills are essential.<\/p>\n<p>Attention to detail, mathematical proficiency and ability to document and track service accounts effectively and thoroughly. <\/p>\n<p>Will be required to be on-call 24\/7 on a rotating basis<\/p>\n<p>Must have reliable transportation and clean driving record<\/p>\n<p>Required Travel up to 25%.<\/p>\n<p><strong><u>WORK ENVIRONMENT \/ CONDITIONS \/ PHYSICAL DEMANDS<\/u><\/strong><strong>:<\/strong><\/p>\n<p>These are considered essential duties and represent the core tasks of the job. The work will primarily be performed outdoors. Employees may be required to complete additional related duties as assigned by management. Reasonable accommodations can be provided to assist individuals with disabilities in performing the essential functions. The work environment will include various manufacturing settings as well as outdoor locations. The role may involve prolonged standing, climbing, pulling, and lifting heavy objects.<\/p>","post_title":"Field Services Technician","post_link":"https:\/\/turnerstaffing.com\/position\/field-services-technician\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"","%location_country%":"United States","%location_city%":"Dallas","%location_state_id%":"TX","%location_state_name%":"Texas","%location_city_state%":"Dallas, TX","%education%":"","%department%":"","%description%":"<p><strong><u>POSITION SUMMARY:<\/u><\/strong><\/p>\n<p>The Field Service Technician will be responsible for providing field support for customer accounts in the South-Central USA region, based out of Dallas\/Fort Worth, TX. The role involves troubleshooting mechanical, electrical, and plumbing system issues, as well as documenting and tracking work hours and project-related costs. The technician will collaborate with skilled trades, contractors, engineers, sales teams, purchasing, accounting, and other resources to ensure excellent service for customer accounts within the assigned territory.<\/p>\n<p><strong><u>ESSENTIAL DUTIES AND RESPONSIBILITIES<\/u><\/strong>:<\/p>\n<p>Formal training in Mechanical, Electrical, Engineering disciplines, or related construction trades. Bachelor's degree is preferred.<\/p>\n<p>5-7 years of prior experience in preventative\/predictive maintenance with industrial mechanical or fluid handling\/pumping systems. A basic understanding of fabrication, metals, welding, project estimation, electrical controls, and mechanical systems in an industrial environment is essential. Strong foundational troubleshooting and technical problem-solving skills are required.<\/p>\n<p>Advanced computer skills, ability to work with web-based systems.<\/p>\n<p>Ability to work independently to achieve assigned tasks<\/p>\n<p>Excellent customer service, time management and personal organizational skills are essential.<\/p>\n<p>Attention to detail, mathematical proficiency and ability to document and track service accounts effectively and thoroughly. <\/p>\n<p>Will be required to be on-call 24\/7 on a rotating basis<\/p>\n<p>Must have reliable transportation and clean driving record<\/p>\n<p>Required Travel up to 25%.<\/p>\n<p><strong><u>WORK ENVIRONMENT \/ CONDITIONS \/ PHYSICAL DEMANDS<\/u><\/strong><strong>:<\/strong><\/p>\n<p>These are considered essential duties and represent the core tasks of the job. The work will primarily be performed outdoors. Employees may be required to complete additional related duties as assigned by management. Reasonable accommodations can be provided to assist individuals with disabilities in performing the essential functions. The work environment will include various manufacturing settings as well as outdoor locations. The role may involve prolonged standing, climbing, pulling, and lifting heavy objects.<\/p>","%category%":"","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/f89975018242-field-services-technician","%breezy_id%":"f89975018242","%breezy_friendly_id%":"f89975018242-field-services-technician","%breezy_created_date%":"2025-03-11T21:05:26.723Z","%breezy_updated_date%":"2025-03-13T12:47:49.771Z","%_wpgmp_location_city%":"Dallas","%_wpgmp_location_state%":"TX","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Dallas, TX, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"32.7766642","%_wpgmp_metabox_longitude%":"-96.7969879","%rank_math_internal_links_processed%":"1"}},"id":2239,"infowindow_disable":false},{"source":"post","title":"HR Coordinator","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    HR Coordinator\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    POSITION SUMMARY: As a Human Resources Coordinator, you will be responsible for assisting the HR department in various administrative tasks&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/hr-coordinator\/\" name=\"HR Coordinator\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"POSITION SUMMARY: As a Human Resources Coordinator, you will be responsible for assisting the HR department in various administrative tasks&hellip;","address":"Gabbs, NV, USA","location":{"lat":"38.8690562","city":"Gabbs","state":"NV","country":"United States","lng":"-117.9228819","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/hr-coordinator\/","zoom":19,"extra_fields":{"post_excerpt":"POSITION SUMMARY: As a Human Resources Coordinator, you will be responsible for assisting the HR department in various administrative tasks&hellip;","post_content":"<p><strong><u>POSITION SUMMARY:<\/u><\/strong><\/p>\n<p>As a Human Resources Coordinator, you will be responsible for assisting the HR department in various administrative tasks and ensuring smooth operations. Your role involves supporting recruitment processes, employee relations, benefits administration, and maintaining HR records for the Gabbs, Nevada facility.<\/p>\n<p><strong><u>ESSENTIAL DUTIES AND RESPONSIBILITIES<\/u><\/strong>:<\/p>\n<p><strong>Recruitment Support:<\/strong><\/p>\n<p>Post open positions, source and screen candidates.<\/p>\n<p>Schedule interviews and communicate with candidates.<\/p>\n<p>Coordinate pre-employment screenings and background checks.<\/p>\n<p>Conduct onboarding and orientation for new hires.<\/p>\n<p>Establish and maintain relationships with recruiting sources.<\/p>\n<p><strong>Employee Records Management:<\/strong><\/p>\n<p>Maintain accurate and up-to-date employee records and HR databases.<\/p>\n<p>Process employee status changes, such as promotions, transfers, and terminations.<\/p>\n<p>Prepare and distribute HR-related documents, including offer letters and contracts.<\/p>\n<p><strong>Benefits Administration:<\/strong><\/p>\n<p>Assist employees with benefits enrollment and inquiries.<\/p>\n<p>Coordinate with benefit providers\/corporate HR and ensure timely processing of enrollments, changes, and terminations.<\/p>\n<p>Support annual benefits open enrollment processes.<\/p>\n<p><strong>Employee Relations:<\/strong><\/p>\n<p>Act as a point of contact for employee inquiries and concerns.<\/p>\n<p>Coordinate and collaborate on community outreach and volunteer efforts.<\/p>\n<p>Collaborate with site management and corporate HR for service awards, and other employee activities.<\/p>\n<p>Assist in resolving employee relations issues and conflicts.<\/p>\n<p>Facilitate communication between employees and management.<\/p>\n<p><strong>HR Compliance and Reporting:<\/strong><\/p>\n<p>Assist in maintaining compliance with HR policies, procedures, and regulations.<\/p>\n<p>Prepare HR-related reports and analytics as required.<\/p>\n<p>Keep abreast of changes in employment laws and regulations.<\/p>\n<p><strong>General Administrative Support:<\/strong><\/p>\n<p>Provide administrative support to the HR department, including scheduling meetings, handling correspondence, and maintaining supplies.<\/p>\n<p>Assist with HR projects and initiatives as needed.<\/p>\n<p><strong>Qualifications and Skills:<\/strong><\/p>\n<p>Bachelor's degree in Human Resources, Business Administration, or related field&nbsp; - preferred<\/p>\n<p>Professional certification \u2013 preferred<\/p>\n<p>3+ years previous experience in HR or administrative roles - preferred.<\/p>\n<p>Strong organizational skills with attention to detail.<\/p>\n<p>Excellent communication and interpersonal skills.<\/p>\n<p>Proficiency in MS Office Suite and HRIS (Ulti-Pro \/ UKG preferred).<\/p>\n<p>Ability to handle sensitive and confidential information with discretion.<\/p>\n<p>Knowledge of employment laws and regulations is a plus.<\/p>\n<p>Must be self-driven, requiring minimum supervision<\/p>\n<p>Demonstrated collaboration skills among various departments and peer groups<\/p>\n<p><strong>Work Environment:<\/strong> The role typically operates in a professional office environment. Occasional flexibility in working hours may be required to accommodate recruitment events or other HR-related activities.<\/p>\n<p>This job description is intended to convey information essential to understanding the scope of the Human Resources Coordinator's position. Duties and responsibilities may be subject to change based on the needs of the organization.<\/p>","post_title":"HR Coordinator","post_link":"https:\/\/turnerstaffing.com\/position\/hr-coordinator\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"","%location_country%":"United States","%location_city%":"Gabbs","%location_state_id%":"NV","%location_state_name%":"Nevada","%location_city_state%":"Gabbs, NV","%education%":"","%department%":"","%description%":"<p><strong><u>POSITION SUMMARY:<\/u><\/strong><\/p>\n<p>As a Human Resources Coordinator, you will be responsible for assisting the HR department in various administrative tasks and ensuring smooth operations. Your role involves supporting recruitment processes, employee relations, benefits administration, and maintaining HR records for the Gabbs, Nevada facility.<\/p>\n<p><strong><u>ESSENTIAL DUTIES AND RESPONSIBILITIES<\/u><\/strong>:<\/p>\n<p><strong>Recruitment Support:<\/strong><\/p>\n<p>Post open positions, source and screen candidates.<\/p>\n<p>Schedule interviews and communicate with candidates.<\/p>\n<p>Coordinate pre-employment screenings and background checks.<\/p>\n<p>Conduct onboarding and orientation for new hires.<\/p>\n<p>Establish and maintain relationships with recruiting sources.<\/p>\n<p><strong>Employee Records Management:<\/strong><\/p>\n<p>Maintain accurate and up-to-date employee records and HR databases.<\/p>\n<p>Process employee status changes, such as promotions, transfers, and terminations.<\/p>\n<p>Prepare and distribute HR-related documents, including offer letters and contracts.<\/p>\n<p><strong>Benefits Administration:<\/strong><\/p>\n<p>Assist employees with benefits enrollment and inquiries.<\/p>\n<p>Coordinate with benefit providers\/corporate HR and ensure timely processing of enrollments, changes, and terminations.<\/p>\n<p>Support annual benefits open enrollment processes.<\/p>\n<p><strong>Employee Relations:<\/strong><\/p>\n<p>Act as a point of contact for employee inquiries and concerns.<\/p>\n<p>Coordinate and collaborate on community outreach and volunteer efforts.<\/p>\n<p>Collaborate with site management and corporate HR for service awards, and other employee activities.<\/p>\n<p>Assist in resolving employee relations issues and conflicts.<\/p>\n<p>Facilitate communication between employees and management.<\/p>\n<p><strong>HR Compliance and Reporting:<\/strong><\/p>\n<p>Assist in maintaining compliance with HR policies, procedures, and regulations.<\/p>\n<p>Prepare HR-related reports and analytics as required.<\/p>\n<p>Keep abreast of changes in employment laws and regulations.<\/p>\n<p><strong>General Administrative Support:<\/strong><\/p>\n<p>Provide administrative support to the HR department, including scheduling meetings, handling correspondence, and maintaining supplies.<\/p>\n<p>Assist with HR projects and initiatives as needed.<\/p>\n<p><strong>Qualifications and Skills:<\/strong><\/p>\n<p>Bachelor's degree in Human Resources, Business Administration, or related field&nbsp; - preferred<\/p>\n<p>Professional certification \u2013 preferred<\/p>\n<p>3+ years previous experience in HR or administrative roles - preferred.<\/p>\n<p>Strong organizational skills with attention to detail.<\/p>\n<p>Excellent communication and interpersonal skills.<\/p>\n<p>Proficiency in MS Office Suite and HRIS (Ulti-Pro \/ UKG preferred).<\/p>\n<p>Ability to handle sensitive and confidential information with discretion.<\/p>\n<p>Knowledge of employment laws and regulations is a plus.<\/p>\n<p>Must be self-driven, requiring minimum supervision<\/p>\n<p>Demonstrated collaboration skills among various departments and peer groups<\/p>\n<p><strong>Work Environment:<\/strong> The role typically operates in a professional office environment. Occasional flexibility in working hours may be required to accommodate recruitment events or other HR-related activities.<\/p>\n<p>This job description is intended to convey information essential to understanding the scope of the Human Resources Coordinator's position. Duties and responsibilities may be subject to change based on the needs of the organization.<\/p>","%category%":"","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/2ec154e6e75c-hr-coordinator","%breezy_id%":"2ec154e6e75c","%breezy_friendly_id%":"2ec154e6e75c-hr-coordinator","%breezy_created_date%":"2025-03-11T21:09:21.453Z","%breezy_updated_date%":"2025-03-12T14:40:54.293Z","%_wpgmp_location_city%":"Gabbs","%_wpgmp_location_state%":"NV","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Gabbs, NV, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"38.8690562","%_wpgmp_metabox_longitude%":"-117.9228819","%rank_math_internal_links_processed%":"1"}},"id":2240,"infowindow_disable":false},{"source":"post","title":"HR Services Specialist","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    HR Services Specialist\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    This onsite, project-based position implements or performs a variety of HR administrative processes and tasks, including employee record-keeping. They often&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/hr-services-specialist\/\" name=\"HR Services Specialist\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"This onsite, project-based position implements or performs a variety of HR administrative processes and tasks, including employee record-keeping. They often&hellip;","address":"Elko, NV, USA","location":{"lat":"40.8436459","city":"Elko","state":"NV","country":"United States","lng":"-115.7526187","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/hr-services-specialist\/","zoom":19,"extra_fields":{"post_excerpt":"This onsite, project-based position implements or performs a variety of HR administrative processes and tasks, including employee record-keeping. They often&hellip;","post_content":"<p>This onsite, project-based position implements or performs a variety of HR administrative processes and tasks, including employee record-keeping. They often handle sensitive employee and company information, which requires that they maintain a high level of professionalism and confidentiality. Focuses on data integrity, definitions, and integrations across systems.<\/p>\n<p>RESPONSIBILITIES<\/p>\n<ul><li>Carry out complex HR data processing tasks; advise colleagues when needed and use expertise to help improve data collection tools and administration processes.<\/li><li>Prepare moderately complex documents using a variety of computer applications such as Microsoft Office. Also responsible for gathering and summarizing data for reports.<\/li><li>Validate, input and maintain time entry systems and process to support the accurate and efficient delivery of payroll services.<\/li><li>Build effective working relationships within the internal client organization, delivering high-quality professional services.<\/li><li>Maintain document management system to manage sensitive employee and company information.<\/li><li>Resolve complex queries from internal or external customers by providing information on policies and\/or procedures, and referring the most complex issues to others.<\/li><li>Initiate and monitor the administration of onboarding and\/or offboarding processes to ensure that all processes are completed accurately, efficiently, and on time.<\/li><li>Develop knowledge and understanding of the organization's policies and procedures and of relevant regulatory codes and codes of conduct to ensure own work adheres to those standards. Obtain authorization from a supervisor or manager for any exceptions.<\/li><li>Provide instruction and informal advice to less experienced colleagues within the team to develop their skills.<\/li><li>Develop own capabilities by participating in assessment and development planning activities as well as formal and informal training and coaching. Develop and maintain an understanding of relevant technology, external regulation, and industry best practices through ongoing education, attending conferences, and reading specialist media.<\/li><li>Prepare or maintain records related to Leaves, using human resources management system software.<\/li><li>Communicate the company\u2019s Leave benefit programs regarding plan options, features, enrollment, and other requirements.<\/li><li>Interpret and explain company Leaves policies, procedures, standards, and \/ or plan documents to employees and leadership.<\/li><li>Provides support for core HR programs, projects (including planning, administration\/execution and tracking of outcomes), communications and platforms.<\/li><li>Acts with attention to detail, delivering accurate work within timeframes and service level expectations.<\/li><li>Maintains Knowledge Base and identifies opportunities for continuous improvement.<\/li><li>Prepare or maintain employment records related to events, such as hiring, termination, leaves, transfers, or promotions, using human resources management system software.<p>QUALIFICATIONS<\/p><ul><li>2-5 years in an office setting required<ul><li>Strong experience in clerical work- Required<ul><li>Intermediate Microsoft office experience (Outlook, Excel, Word, PowerPoint etc..) - Required<\/li><li>Experience in Data Entry -Required<\/li><li>Type a minimum 60 work a minute- Required<\/li><li>Human Resources or Benefits experience \u2013 Preferred<\/li><li>Experience with a multi-line phone system preferred<p>Education<\/p><\/li><\/ul><\/li><\/ul><\/li><li>High school diploma or equivalent required<\/li><li>Associates or bachelor\u2019s degree preferred<\/li><li>Authorized to work in the US without work visa sponsorship<\/li><li>Local candidates only, as relocation not provided<\/li><\/ul><\/li><\/ul>","post_title":"HR Services Specialist","post_link":"https:\/\/turnerstaffing.com\/position\/hr-services-specialist\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"","%location_country%":"United States","%location_city%":"Elko","%location_state_id%":"NV","%location_state_name%":"Nevada","%location_city_state%":"Elko, NV","%education%":"Associate Degree","%department%":"","%description%":"<p>This onsite, project-based position implements or performs a variety of HR administrative processes and tasks, including employee record-keeping. They often handle sensitive employee and company information, which requires that they maintain a high level of professionalism and confidentiality. Focuses on data integrity, definitions, and integrations across systems.<\/p>\n<p>RESPONSIBILITIES<\/p>\n<ul><li>Carry out complex HR data processing tasks; advise colleagues when needed and use expertise to help improve data collection tools and administration processes.<\/li><li>Prepare moderately complex documents using a variety of computer applications such as Microsoft Office. Also responsible for gathering and summarizing data for reports.<\/li><li>Validate, input and maintain time entry systems and process to support the accurate and efficient delivery of payroll services.<\/li><li>Build effective working relationships within the internal client organization, delivering high-quality professional services.<\/li><li>Maintain document management system to manage sensitive employee and company information.<\/li><li>Resolve complex queries from internal or external customers by providing information on policies and\/or procedures, and referring the most complex issues to others.<\/li><li>Initiate and monitor the administration of onboarding and\/or offboarding processes to ensure that all processes are completed accurately, efficiently, and on time.<\/li><li>Develop knowledge and understanding of the organization's policies and procedures and of relevant regulatory codes and codes of conduct to ensure own work adheres to those standards. Obtain authorization from a supervisor or manager for any exceptions.<\/li><li>Provide instruction and informal advice to less experienced colleagues within the team to develop their skills.<\/li><li>Develop own capabilities by participating in assessment and development planning activities as well as formal and informal training and coaching. Develop and maintain an understanding of relevant technology, external regulation, and industry best practices through ongoing education, attending conferences, and reading specialist media.<\/li><li>Prepare or maintain records related to Leaves, using human resources management system software.<\/li><li>Communicate the company\u2019s Leave benefit programs regarding plan options, features, enrollment, and other requirements.<\/li><li>Interpret and explain company Leaves policies, procedures, standards, and \/ or plan documents to employees and leadership.<\/li><li>Provides support for core HR programs, projects (including planning, administration\/execution and tracking of outcomes), communications and platforms.<\/li><li>Acts with attention to detail, delivering accurate work within timeframes and service level expectations.<\/li><li>Maintains Knowledge Base and identifies opportunities for continuous improvement.<\/li><li>Prepare or maintain employment records related to events, such as hiring, termination, leaves, transfers, or promotions, using human resources management system software.<p>QUALIFICATIONS<\/p><ul><li>2-5 years in an office setting required<ul><li>Strong experience in clerical work- Required<ul><li>Intermediate Microsoft office experience (Outlook, Excel, Word, PowerPoint etc..) - Required<\/li><li>Experience in Data Entry -Required<\/li><li>Type a minimum 60 work a minute- Required<\/li><li>Human Resources or Benefits experience \u2013 Preferred<\/li><li>Experience with a multi-line phone system preferred<p>Education<\/p><\/li><\/ul><\/li><\/ul><\/li><li>High school diploma or equivalent required<\/li><li>Associates or bachelor\u2019s degree preferred<\/li><li>Authorized to work in the US without work visa sponsorship<\/li><li>Local candidates only, as relocation not provided<\/li><\/ul><\/li><\/ul>","%category%":"Human Resources","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/9d4b565edebd-hr-services-specialist","%breezy_id%":"9d4b565edebd","%breezy_friendly_id%":"9d4b565edebd-hr-services-specialist","%breezy_created_date%":"2025-03-11T14:12:16.920Z","%breezy_updated_date%":"2025-03-11T14:13:47.817Z","%_wpgmp_location_city%":"Elko","%_wpgmp_location_state%":"NV","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Elko, NV, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"40.8436459","%_wpgmp_metabox_longitude%":"-115.7526187","%rank_math_internal_links_processed%":"1"}},"id":2237,"infowindow_disable":false},{"source":"post","title":"Operational Excellence Manager","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Operational Excellence Manager\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    POSITION SUMMARY: The Operational Excellence Manager (OEM) works with all functional areas to prepare, train, and conduct continuous improvement initiatives&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/operational-excellence-manager\/\" name=\"Operational Excellence Manager\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"POSITION SUMMARY: The Operational Excellence Manager (OEM) works with all functional areas to prepare, train, and conduct continuous improvement initiatives&hellip;","address":"Waynesville, NC, USA","location":{"lat":"35.4887145","city":"Waynesville","state":"NC","country":"United States","lng":"-82.9887477","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/operational-excellence-manager\/","zoom":19,"extra_fields":{"post_excerpt":"POSITION SUMMARY: The Operational Excellence Manager (OEM) works with all functional areas to prepare, train, and conduct continuous improvement initiatives&hellip;","post_content":"<p><strong><u>POSITION SUMMARY:<\/u><\/strong><br><\/p><p>The Operational Excellence Manager (OEM) works with all functional areas to prepare, train, and conduct continuous improvement initiatives for the corporation.&nbsp; The OEM will develop and prepare materials for use in such events, coordinate with department managers and participants, lead instruction on the use of process improvement tools, facilitate team decisions, monitor teamwork, use available resources to help resolve team conflict, assist in the development of implementation action plans, and conduct follow-up.&nbsp; The OEM will work across multiple disciplines to achieve efficiency, reduce waste and streamline processes. <\/p><p><strong><u>ESSENTIAL DUTIES AND RESPONSIBILITIES<\/u><\/strong>:<\/p>\n<p>Adheres to all company Policies and Procedures and actively acts as enterprise champion for Continuous Improvement and its activities and services to others. <\/p>\n<p>Participates in design, execution, training, and maintenance of Continuous Improvement Process Best Practices (CMP-CIP).&nbsp; Leads site self-assessment of performance vs. Best Practices and occasionally assesses other CMP sites for performance vs. Best Practices. <\/p>\n<p>Presents, facilitates, and leads assigned process improvement events using CMP-CIP Lean and Six Sigma Methods.&nbsp; As organizational capability is built in these techniques, act as champion and mentor to event leaders utilizing these methods to lead events.&nbsp; <\/p>\n<p>Seeks and evaluates process improvement and Lean Enterprise information, materials, and methods to match specific organizational needs as outlined by management and adapts them to use in the execution of process improvement events. <\/p>\n<p>Provides event follow-up to monitor the progress of planned improvement implementation to assure timely action, appropriate management support, proper allocation of resources and achievement of expected benefits. <\/p>\n<p>Develops and publishes reports of overall Continuous Improvement activities including accomplishments, participation, projected activities, and anticipated needs. <\/p>\n<p>Coordinates with related departments and functions to assure appropriate information flow and understanding of overall process improvement direction.<\/p>\n<p>Build and foster a culture\/environment for and enable employee involvement in project development and\/or execution.<\/p>\n<p>Responsible for the measurement and assurance of compliance to stated expectations consistently across all teams and shifts.<\/p>\n<p>Form, provide structure to and document progress of cells or work teams that target continued improvement in regard to Culture, Safety, Cleanliness, Efficiency, and Improved Processes. <\/p>\n<p>Report and follow up on deviations from target in a proactive manner.<\/p>\n<p>Support the Leadership team on other projects or assignments as needed<\/p>\n<p>Maintain Discipline\/Compliance Log and help facilitate corrective actions with appropriate supervisors\/managers as needed.<br>\n<br>\n<\/p><p><strong>Travel Requirements&nbsp;&nbsp; <\/strong><\/p>\n<p>    &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; 20% visits sites periodically (Primarily IN\/NV)<\/p>\n<p><strong>Special Knowledge, Skills and Training<\/strong><\/p>\n<p>Minimum of five years of related operational excellence management experience needed.<\/p>\n<p>Experience in Lean Enterprise principles and methods, team development, leadership techniques and project management methods. <\/p>\n<p>Keen team leadership, problem analysis and solving, and process improvement skills. <\/p>\n<p>Excellent collaboration skills and demonstrated self-driven initiative.<\/p>\n<p>Six Sigma \/ Lean Certification or equivalent hand-on experience or training is preferred.<\/p>\n<p>Ability to establish monitoring and\/or data collection systems to support team activities quickly and effectively. <\/p>\n<p>Flexibility to work any shift as needed.&nbsp; Although primarily 8-5\/M-F position will require regular monitoring and follow-up on off-shift hours. <\/p>\n<p>Advanced project management and computer software experience, comfortable with oral and written presentations.<\/p>\n<p>Strong interpersonal and leadership skills, ability to build relationships, negotiate successfully, and to train, mentor and develop others.&nbsp;&nbsp; <\/p>\n<p>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; <\/p>\n<p><strong>Education:&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; <\/strong><\/p>\n<p>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; Bachelor\u2019s Degree in engineering or business discipline, with advanced training and\/or certification in Lean, Six-Sigma, or other related continuous improvement processes at \u201cTrainer\u201d level.&nbsp; <\/p><p><\/p>","post_title":"Operational Excellence Manager","post_link":"https:\/\/turnerstaffing.com\/position\/operational-excellence-manager\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"","%location_country%":"United States","%location_city%":"Waynesville","%location_state_id%":"NC","%location_state_name%":"North Carolina","%location_city_state%":"Waynesville, NC","%education%":"","%department%":"","%description%":"<p><strong><u>POSITION SUMMARY:<\/u><\/strong><br><\/p><p>The Operational Excellence Manager (OEM) works with all functional areas to prepare, train, and conduct continuous improvement initiatives for the corporation.&nbsp; The OEM will develop and prepare materials for use in such events, coordinate with department managers and participants, lead instruction on the use of process improvement tools, facilitate team decisions, monitor teamwork, use available resources to help resolve team conflict, assist in the development of implementation action plans, and conduct follow-up.&nbsp; The OEM will work across multiple disciplines to achieve efficiency, reduce waste and streamline processes. <\/p><p><strong><u>ESSENTIAL DUTIES AND RESPONSIBILITIES<\/u><\/strong>:<\/p>\n<p>Adheres to all company Policies and Procedures and actively acts as enterprise champion for Continuous Improvement and its activities and services to others. <\/p>\n<p>Participates in design, execution, training, and maintenance of Continuous Improvement Process Best Practices (CMP-CIP).&nbsp; Leads site self-assessment of performance vs. Best Practices and occasionally assesses other CMP sites for performance vs. Best Practices. <\/p>\n<p>Presents, facilitates, and leads assigned process improvement events using CMP-CIP Lean and Six Sigma Methods.&nbsp; As organizational capability is built in these techniques, act as champion and mentor to event leaders utilizing these methods to lead events.&nbsp; <\/p>\n<p>Seeks and evaluates process improvement and Lean Enterprise information, materials, and methods to match specific organizational needs as outlined by management and adapts them to use in the execution of process improvement events. <\/p>\n<p>Provides event follow-up to monitor the progress of planned improvement implementation to assure timely action, appropriate management support, proper allocation of resources and achievement of expected benefits. <\/p>\n<p>Develops and publishes reports of overall Continuous Improvement activities including accomplishments, participation, projected activities, and anticipated needs. <\/p>\n<p>Coordinates with related departments and functions to assure appropriate information flow and understanding of overall process improvement direction.<\/p>\n<p>Build and foster a culture\/environment for and enable employee involvement in project development and\/or execution.<\/p>\n<p>Responsible for the measurement and assurance of compliance to stated expectations consistently across all teams and shifts.<\/p>\n<p>Form, provide structure to and document progress of cells or work teams that target continued improvement in regard to Culture, Safety, Cleanliness, Efficiency, and Improved Processes. <\/p>\n<p>Report and follow up on deviations from target in a proactive manner.<\/p>\n<p>Support the Leadership team on other projects or assignments as needed<\/p>\n<p>Maintain Discipline\/Compliance Log and help facilitate corrective actions with appropriate supervisors\/managers as needed.<br>\n<br>\n<\/p><p><strong>Travel Requirements&nbsp;&nbsp; <\/strong><\/p>\n<p>    &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; 20% visits sites periodically (Primarily IN\/NV)<\/p>\n<p><strong>Special Knowledge, Skills and Training<\/strong><\/p>\n<p>Minimum of five years of related operational excellence management experience needed.<\/p>\n<p>Experience in Lean Enterprise principles and methods, team development, leadership techniques and project management methods. <\/p>\n<p>Keen team leadership, problem analysis and solving, and process improvement skills. <\/p>\n<p>Excellent collaboration skills and demonstrated self-driven initiative.<\/p>\n<p>Six Sigma \/ Lean Certification or equivalent hand-on experience or training is preferred.<\/p>\n<p>Ability to establish monitoring and\/or data collection systems to support team activities quickly and effectively. <\/p>\n<p>Flexibility to work any shift as needed.&nbsp; Although primarily 8-5\/M-F position will require regular monitoring and follow-up on off-shift hours. <\/p>\n<p>Advanced project management and computer software experience, comfortable with oral and written presentations.<\/p>\n<p>Strong interpersonal and leadership skills, ability to build relationships, negotiate successfully, and to train, mentor and develop others.&nbsp;&nbsp; <\/p>\n<p>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; <\/p>\n<p><strong>Education:&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; <\/strong><\/p>\n<p>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; Bachelor\u2019s Degree in engineering or business discipline, with advanced training and\/or certification in Lean, Six-Sigma, or other related continuous improvement processes at \u201cTrainer\u201d level.&nbsp; <\/p><p><\/p>","%category%":"","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/3a1533545df0-operational-excellence-manager","%breezy_id%":"3a1533545df0","%breezy_friendly_id%":"3a1533545df0-operational-excellence-manager","%breezy_created_date%":"2025-03-11T21:00:04.166Z","%breezy_updated_date%":"2025-03-12T14:39:39.109Z","%_wpgmp_location_city%":"Waynesville","%_wpgmp_location_state%":"NC","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Waynesville, NC, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"35.4887145","%_wpgmp_metabox_longitude%":"-82.9887477","%rank_math_internal_links_processed%":"1"}},"id":2238,"infowindow_disable":false},{"source":"post","title":"Loader Operator &#8211; CAT 988\/990","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Loader Operator &#8211; CAT 988\/990\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Looking to hire an operator who can operate a CAT 988\/990 loader to load haul trucks.&nbsp; Responsibilities: &#8211; Operate heavy&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/loader-operator-2\/\" name=\"Loader Operator &#8211; CAT 988\/990\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Looking to hire an operator who can operate a CAT 988\/990 loader to load haul trucks.&nbsp; Responsibilities: &#8211; Operate heavy&hellip;","address":"Bridgeport, TX, USA","location":{"lat":"33.2101155","city":"Bridgeport","state":"TX","country":"United States","lng":"-97.7547552","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/loader-operator-2\/","zoom":19,"extra_fields":{"post_excerpt":"Looking to hire an operator who can operate a CAT 988\/990 loader to load haul trucks.&nbsp; Responsibilities: &#8211; Operate heavy&hellip;","post_content":"<p>Looking to hire an operator who can operate a CAT 988\/990 loader to load haul trucks.&nbsp;<br><br>Responsibilities:<br><br>- Operate heavy equipment to move materials, run a riprap plant,&nbsp;load, and unload trucks, and prepare job sites<br><br>- Perform routine maintenance on equipment and ensure proper operation<br><br>- Communicate effectively with team members and supervisors<br><br>- Follow safety guidelines and protocols at all ties<br><br>- Work efficiently to meet project deadlines<\/p>","post_title":"Loader Operator &#8211; CAT 988\/990","post_link":"https:\/\/turnerstaffing.com\/position\/loader-operator-2\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"","%location_country%":"United States","%location_city%":"Bridgeport","%location_state_id%":"TX","%location_state_name%":"Texas","%location_city_state%":"Bridgeport, TX","%education%":"","%department%":"","%description%":"<p>Looking to hire an operator who can operate a CAT 988\/990 loader to load haul trucks.&nbsp;<br><br>Responsibilities:<br><br>- Operate heavy equipment to move materials, run a riprap plant,&nbsp;load, and unload trucks, and prepare job sites<br><br>- Perform routine maintenance on equipment and ensure proper operation<br><br>- Communicate effectively with team members and supervisors<br><br>- Follow safety guidelines and protocols at all ties<br><br>- Work efficiently to meet project deadlines<\/p>","%category%":"","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/c04f8a0dbe3f-loader-operator-cat-988-990","%breezy_id%":"c04f8a0dbe3f","%breezy_friendly_id%":"c04f8a0dbe3f-loader-operator-cat-988-990","%breezy_created_date%":"2024-12-03T21:36:06.679Z","%breezy_updated_date%":"2025-03-24T14:34:50.120Z","%_wpgmp_location_city%":"Bridgeport","%_wpgmp_location_state%":"TX","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Bridgeport, TX, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"33.2101155","%_wpgmp_metabox_longitude%":"-97.7547552","%rank_math_internal_links_processed%":"1"}},"id":2236,"infowindow_disable":false},{"source":"post","title":"Grading\/Mass Excavation Foreman","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Grading\/Mass Excavation Foreman\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Position Overview: We are seeking a skilled and motivated Grading\/Mass Excavation Foreman to oversee and lead grading and excavation operations&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/grading-mass-excavation-foreman\/\" name=\"Grading\/Mass Excavation Foreman\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Position Overview: We are seeking a skilled and motivated Grading\/Mass Excavation Foreman to oversee and lead grading and excavation operations&hellip;","address":"Winchester, VA, USA","location":{"lat":"39.1856597","city":"Winchester","state":"VA","country":"United States","lng":"-78.1633341","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/grading-mass-excavation-foreman\/","zoom":19,"extra_fields":{"post_excerpt":"Position Overview: We are seeking a skilled and motivated Grading\/Mass Excavation Foreman to oversee and lead grading and excavation operations&hellip;","post_content":"<p><strong>Position Overview:<\/strong><br>\nWe are seeking a skilled and motivated Grading\/Mass Excavation Foreman to oversee and lead grading and excavation operations on wet utilities civil construction projects. This role requires hands-on experience in grading, mass excavation, and utility installation, with a strong focus on safety, quality, and meeting project deadlines. The ideal candidate will have a proven track record of managing field crews, coordinating equipment, and ensuring that projects are completed in compliance with plans and specifications.<\/p>\n<p><strong>Key Responsibilities:<\/strong><\/p>\n<ul>\n<li><strong>Supervise Excavation Operations:<\/strong> Lead and oversee all grading and mass excavation activities, ensuring proper techniques are used to prepare sites for utility installation, including stormwater, sewer, and water systems.<\/li>\n<li><strong>Crew Leadership:<\/strong> Manage, motivate, and direct a team of equipment operators, laborers, and other workers on-site to ensure productivity and safety.<\/li>\n<li><strong>Project Coordination:<\/strong> Coordinate with project managers, engineers, and other stakeholders to ensure work aligns with project specifications, timelines, and budget.<\/li>\n<li><strong>Quality Control:<\/strong> Monitor work for accuracy and quality, ensuring all grading and excavation meets project requirements and safety standards.<\/li>\n<li><strong>Safety Compliance:<\/strong> Enforce strict safety protocols and standards on-site to minimize risks and maintain compliance with OSHA and other safety regulations.<\/li>\n<li><strong>Equipment Management:<\/strong> Ensure that heavy equipment (e.g., dozers, excavators, dump trucks) is properly maintained and operated. Work with the team to perform routine equipment inspections and report any issues.<\/li>\n<li><strong>Scheduling:<\/strong> Develop and maintain daily work schedules for grading and excavation tasks. Ensure the crew is efficiently assigned to appropriate tasks and that deadlines are met.<\/li>\n<li><strong>Problem Solving:<\/strong> Identify and address any obstacles or issues that arise during the excavation process, working to resolve them promptly and without delay.<\/li>\n<li><strong>Documentation and Reporting:<\/strong> Maintain accurate records of work completed, including daily logs, time sheets, and any material or equipment used. Report progress to project managers and communicate any changes or challenges.<\/li>\n<li><strong>Collaborate with Stakeholders:<\/strong> Regularly communicate with project managers, site engineers, and clients to ensure alignment and resolve any issues in the field.<\/li>\n<\/ul>\n<p><strong>Qualifications:<\/strong><\/p>\n<ul>\n<li><strong>Experience:<\/strong> Minimum of 5 years of experience in grading, mass excavation, and wet utilities installation in a civil construction setting. At least 2 years in a supervisory or foreman role.<\/li>\n<li><strong>Leadership:<\/strong> Proven ability to lead and manage a crew, including delegating tasks, monitoring performance, and motivating staff.<\/li>\n<li><strong>Technical Knowledge:<\/strong> Strong understanding of grading, excavation, and wet utility construction methods, as well as reading and interpreting blueprints and project specifications.<\/li>\n<li><strong>Safety Expertise:<\/strong> In-depth knowledge of OSHA safety regulations and the ability to enforce safety standards on-site.<\/li>\n<li><strong>Problem-Solving Skills:<\/strong> Ability to address and resolve issues that arise on the job site quickly and effectively.<\/li>\n<li><strong>Communication Skills:<\/strong> Excellent verbal and written communication skills to liaise with team members, project managers, and clients.<\/li>\n<li><strong>Physical Requirements:<\/strong> Ability to work outdoors in all weather conditions, lift heavy materials, and perform physically demanding tasks.<\/li>\n<li><strong>Certifications:<\/strong> OSHA 10\/30-Hour Certification (preferred). Heavy equipment operation certification or experience is a plus.<\/li>\n<li><strong>Driver\u2019s License:<\/strong> Valid driver\u2019s license with a clean driving record. CDL is a plus but not required.<\/li><\/ul>","post_title":"Grading\/Mass Excavation Foreman","post_link":"https:\/\/turnerstaffing.com\/position\/grading-mass-excavation-foreman\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Senior","%location_country%":"United States","%location_city%":"Winchester","%location_state_id%":"VA","%location_state_name%":"Virginia","%location_city_state%":"Winchester, VA","%education%":"Unspecified","%department%":"","%description%":"<p><strong>Position Overview:<\/strong><br>\nWe are seeking a skilled and motivated Grading\/Mass Excavation Foreman to oversee and lead grading and excavation operations on wet utilities civil construction projects. This role requires hands-on experience in grading, mass excavation, and utility installation, with a strong focus on safety, quality, and meeting project deadlines. The ideal candidate will have a proven track record of managing field crews, coordinating equipment, and ensuring that projects are completed in compliance with plans and specifications.<\/p>\n<p><strong>Key Responsibilities:<\/strong><\/p>\n<ul>\n<li><strong>Supervise Excavation Operations:<\/strong> Lead and oversee all grading and mass excavation activities, ensuring proper techniques are used to prepare sites for utility installation, including stormwater, sewer, and water systems.<\/li>\n<li><strong>Crew Leadership:<\/strong> Manage, motivate, and direct a team of equipment operators, laborers, and other workers on-site to ensure productivity and safety.<\/li>\n<li><strong>Project Coordination:<\/strong> Coordinate with project managers, engineers, and other stakeholders to ensure work aligns with project specifications, timelines, and budget.<\/li>\n<li><strong>Quality Control:<\/strong> Monitor work for accuracy and quality, ensuring all grading and excavation meets project requirements and safety standards.<\/li>\n<li><strong>Safety Compliance:<\/strong> Enforce strict safety protocols and standards on-site to minimize risks and maintain compliance with OSHA and other safety regulations.<\/li>\n<li><strong>Equipment Management:<\/strong> Ensure that heavy equipment (e.g., dozers, excavators, dump trucks) is properly maintained and operated. Work with the team to perform routine equipment inspections and report any issues.<\/li>\n<li><strong>Scheduling:<\/strong> Develop and maintain daily work schedules for grading and excavation tasks. Ensure the crew is efficiently assigned to appropriate tasks and that deadlines are met.<\/li>\n<li><strong>Problem Solving:<\/strong> Identify and address any obstacles or issues that arise during the excavation process, working to resolve them promptly and without delay.<\/li>\n<li><strong>Documentation and Reporting:<\/strong> Maintain accurate records of work completed, including daily logs, time sheets, and any material or equipment used. Report progress to project managers and communicate any changes or challenges.<\/li>\n<li><strong>Collaborate with Stakeholders:<\/strong> Regularly communicate with project managers, site engineers, and clients to ensure alignment and resolve any issues in the field.<\/li>\n<\/ul>\n<p><strong>Qualifications:<\/strong><\/p>\n<ul>\n<li><strong>Experience:<\/strong> Minimum of 5 years of experience in grading, mass excavation, and wet utilities installation in a civil construction setting. At least 2 years in a supervisory or foreman role.<\/li>\n<li><strong>Leadership:<\/strong> Proven ability to lead and manage a crew, including delegating tasks, monitoring performance, and motivating staff.<\/li>\n<li><strong>Technical Knowledge:<\/strong> Strong understanding of grading, excavation, and wet utility construction methods, as well as reading and interpreting blueprints and project specifications.<\/li>\n<li><strong>Safety Expertise:<\/strong> In-depth knowledge of OSHA safety regulations and the ability to enforce safety standards on-site.<\/li>\n<li><strong>Problem-Solving Skills:<\/strong> Ability to address and resolve issues that arise on the job site quickly and effectively.<\/li>\n<li><strong>Communication Skills:<\/strong> Excellent verbal and written communication skills to liaise with team members, project managers, and clients.<\/li>\n<li><strong>Physical Requirements:<\/strong> Ability to work outdoors in all weather conditions, lift heavy materials, and perform physically demanding tasks.<\/li>\n<li><strong>Certifications:<\/strong> OSHA 10\/30-Hour Certification (preferred). Heavy equipment operation certification or experience is a plus.<\/li>\n<li><strong>Driver\u2019s License:<\/strong> Valid driver\u2019s license with a clean driving record. CDL is a plus but not required.<\/li><\/ul>","%category%":"Management","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/f896c1f4ab52-grading-mass-excavation-foreman","%breezy_id%":"f896c1f4ab52","%breezy_friendly_id%":"f896c1f4ab52-grading-mass-excavation-foreman","%breezy_created_date%":"2025-03-10T16:54:53.207Z","%breezy_updated_date%":"2025-03-10T16:55:38.648Z","%_wpgmp_location_city%":"Winchester","%_wpgmp_location_state%":"VA","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Winchester, VA, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"39.1856597","%_wpgmp_metabox_longitude%":"-78.1633341","%rank_math_internal_links_processed%":"1"}},"id":2234,"infowindow_disable":false},{"source":"post","title":"Civil Construction Office Manager","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Civil Construction Office Manager\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Position Overview: We are looking for a highly organized and detail-oriented Office Manager to oversee Accounts Payable (AP), Accounts Receivable&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/civil-construction-office-manager\/\" name=\"Civil Construction Office Manager\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Position Overview: We are looking for a highly organized and detail-oriented Office Manager to oversee Accounts Payable (AP), Accounts Receivable&hellip;","address":"Winchester, VA, USA","location":{"lat":"39.1856597","city":"Winchester","state":"VA","country":"United States","lng":"-78.1633341","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/civil-construction-office-manager\/","zoom":19,"extra_fields":{"post_excerpt":"Position Overview: We are looking for a highly organized and detail-oriented Office Manager to oversee Accounts Payable (AP), Accounts Receivable&hellip;","post_content":"<p><strong>Position Overview:<\/strong><br>\nWe are looking for a highly organized and detail-oriented Office Manager to oversee Accounts Payable (AP), Accounts Receivable (AR), and Payroll functions for our civil construction projects, specifically in the wet utilities sector. This role is crucial for ensuring smooth office operations, accurate financial recordkeeping, and compliance with company policies. The ideal candidate will have a strong background in construction accounting, excellent communication skills, and the ability to manage multiple tasks in a fast-paced environment.<\/p>\n<p><strong>Key Responsibilities:<\/strong><\/p>\n<ul>\n<li>\n<p><strong>Accounts Payable (AP):<\/strong><\/p>\n<ul>\n<li>Process vendor invoices, ensuring they are accurate, properly approved, and paid on time.<\/li>\n<li>Maintain relationships with vendors to resolve any discrepancies and ensure timely payments.<\/li>\n<li>Reconcile AP statements and ensure all outstanding invoices are tracked and cleared.<\/li>\n<li>Monitor cash flow and ensure adequate funds are available for vendor payments.<\/li>\n<\/ul>\n<\/li>\n<li>\n<p><strong>Accounts Receivable (AR):<\/strong><\/p>\n<ul>\n<li>Manage customer invoicing, ensuring all work completed is accurately billed according to contract terms.<\/li>\n<li>Track payments, follow up on overdue invoices, and assist with collections when necessary.<\/li>\n<li>Prepare and maintain AR aging reports for management review.<\/li>\n<li>Coordinate with project managers to ensure timely invoicing for completed work.<\/li>\n<\/ul>\n<\/li>\n<li>\n<p><strong>Payroll Management:<\/strong><\/p>\n<ul>\n<li>Process weekly, bi-weekly, or monthly payroll for all employees, ensuring accuracy and compliance with company policies and local\/state\/federal regulations.<\/li>\n<li>Maintain accurate records of employee hours, overtime, bonuses, and deductions.<\/li>\n<li>Handle payroll taxes, including filing and reporting.<\/li>\n<li>Respond to employee payroll inquiries and resolve issues in a timely manner.<\/li>\n<\/ul>\n<\/li>\n<li>\n<p><strong>Office Administration:<\/strong><\/p>\n<ul>\n<li>Manage general office duties including filing, organizing records, and maintaining office supplies.<\/li>\n<li>Provide administrative support to management and project teams as needed.<\/li>\n<li>Ensure office policies and procedures are followed, maintaining a smooth workflow.<\/li>\n<li>Assist with preparing and submitting reports, documentation, and compliance forms.<\/li>\n<\/ul>\n<\/li>\n<li>\n<p><strong>Reporting and Reconciliation:<\/strong><\/p>\n<ul>\n<li>Prepare regular financial reports (AP, AR, and Payroll) for management review.<\/li>\n<li>Reconcile bank accounts and credit card statements.<\/li>\n<li>Support internal and external audits by providing required documentation and financial records.<\/li>\n<li>Assist with month-end and year-end closing processes.<\/li>\n<\/ul>\n<\/li>\n<li>\n<p><strong>Compliance &amp; Regulations:<\/strong><\/p>\n<ul>\n<li>Ensure adherence to all federal, state, and local tax regulations, including proper tax withholding and reporting for payroll.<\/li>\n<li>Stay updated on changes in tax laws and regulations affecting the construction industry.<\/li>\n<li>Maintain confidentiality and secure handling of all financial information.<\/li>\n<\/ul>\n<\/li>\n<\/ul>\n<p><strong>Qualifications:<\/strong><\/p>\n<ul>\n<li>\n<p><strong>Experience:<\/strong><\/p>\n<ul>\n<li>Minimum of 3-5 years of experience in office management or accounting, with a focus on Accounts Payable, Accounts Receivable, and Payroll functions.<\/li>\n<li>Experience in the construction or civil engineering industry, particularly in wet utilities, is highly preferred.<\/li>\n<\/ul>\n<\/li>\n<li>\n<p><strong>Skills:<\/strong><\/p>\n<ul>\n<li>Strong knowledge of accounting principles and construction industry-specific accounting practices.<\/li>\n<li>Proficient in accounting software (e.g., QuickBooks, Procore, Viewpoint) and Microsoft Office Suite (Excel, Word, Outlook).<\/li>\n<li>Exceptional organizational skills and attention to detail.<\/li>\n<li>Excellent written and verbal communication skills.<\/li>\n<li>Strong ability to manage time effectively, prioritize tasks, and meet deadlines.<\/li>\n<\/ul>\n<\/li>\n<li>\n<p><strong>Certifications:<\/strong><\/p>\n<ul>\n<li>Certification in accounting (e.g., CPA, CMA) or payroll processing (e.g., FPC or CPP) is a plus, but not required.<\/li>\n<li>OSHA or other construction safety certifications are an added benefit.<\/li>\n<\/ul>\n<\/li>\n<li>\n<p><strong>Personal Attributes:<\/strong><\/p>\n<ul>\n<li>Ability to work independently and as part of a team.<\/li>\n<li>Strong problem-solving skills and initiative.<\/li>\n<li>High level of integrity and ability to maintain confidentiality.<\/li>\n<li>Ability to work in a fast-paced, deadline-driven environment.<\/li><\/ul><\/li><\/ul>","post_title":"Civil Construction Office Manager","post_link":"https:\/\/turnerstaffing.com\/position\/civil-construction-office-manager\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Mid Level","%location_country%":"United States","%location_city%":"Winchester","%location_state_id%":"VA","%location_state_name%":"Virginia","%location_city_state%":"Winchester, VA","%education%":"Unspecified","%department%":"","%description%":"<p><strong>Position Overview:<\/strong><br>\nWe are looking for a highly organized and detail-oriented Office Manager to oversee Accounts Payable (AP), Accounts Receivable (AR), and Payroll functions for our civil construction projects, specifically in the wet utilities sector. This role is crucial for ensuring smooth office operations, accurate financial recordkeeping, and compliance with company policies. The ideal candidate will have a strong background in construction accounting, excellent communication skills, and the ability to manage multiple tasks in a fast-paced environment.<\/p>\n<p><strong>Key Responsibilities:<\/strong><\/p>\n<ul>\n<li>\n<p><strong>Accounts Payable (AP):<\/strong><\/p>\n<ul>\n<li>Process vendor invoices, ensuring they are accurate, properly approved, and paid on time.<\/li>\n<li>Maintain relationships with vendors to resolve any discrepancies and ensure timely payments.<\/li>\n<li>Reconcile AP statements and ensure all outstanding invoices are tracked and cleared.<\/li>\n<li>Monitor cash flow and ensure adequate funds are available for vendor payments.<\/li>\n<\/ul>\n<\/li>\n<li>\n<p><strong>Accounts Receivable (AR):<\/strong><\/p>\n<ul>\n<li>Manage customer invoicing, ensuring all work completed is accurately billed according to contract terms.<\/li>\n<li>Track payments, follow up on overdue invoices, and assist with collections when necessary.<\/li>\n<li>Prepare and maintain AR aging reports for management review.<\/li>\n<li>Coordinate with project managers to ensure timely invoicing for completed work.<\/li>\n<\/ul>\n<\/li>\n<li>\n<p><strong>Payroll Management:<\/strong><\/p>\n<ul>\n<li>Process weekly, bi-weekly, or monthly payroll for all employees, ensuring accuracy and compliance with company policies and local\/state\/federal regulations.<\/li>\n<li>Maintain accurate records of employee hours, overtime, bonuses, and deductions.<\/li>\n<li>Handle payroll taxes, including filing and reporting.<\/li>\n<li>Respond to employee payroll inquiries and resolve issues in a timely manner.<\/li>\n<\/ul>\n<\/li>\n<li>\n<p><strong>Office Administration:<\/strong><\/p>\n<ul>\n<li>Manage general office duties including filing, organizing records, and maintaining office supplies.<\/li>\n<li>Provide administrative support to management and project teams as needed.<\/li>\n<li>Ensure office policies and procedures are followed, maintaining a smooth workflow.<\/li>\n<li>Assist with preparing and submitting reports, documentation, and compliance forms.<\/li>\n<\/ul>\n<\/li>\n<li>\n<p><strong>Reporting and Reconciliation:<\/strong><\/p>\n<ul>\n<li>Prepare regular financial reports (AP, AR, and Payroll) for management review.<\/li>\n<li>Reconcile bank accounts and credit card statements.<\/li>\n<li>Support internal and external audits by providing required documentation and financial records.<\/li>\n<li>Assist with month-end and year-end closing processes.<\/li>\n<\/ul>\n<\/li>\n<li>\n<p><strong>Compliance &amp; Regulations:<\/strong><\/p>\n<ul>\n<li>Ensure adherence to all federal, state, and local tax regulations, including proper tax withholding and reporting for payroll.<\/li>\n<li>Stay updated on changes in tax laws and regulations affecting the construction industry.<\/li>\n<li>Maintain confidentiality and secure handling of all financial information.<\/li>\n<\/ul>\n<\/li>\n<\/ul>\n<p><strong>Qualifications:<\/strong><\/p>\n<ul>\n<li>\n<p><strong>Experience:<\/strong><\/p>\n<ul>\n<li>Minimum of 3-5 years of experience in office management or accounting, with a focus on Accounts Payable, Accounts Receivable, and Payroll functions.<\/li>\n<li>Experience in the construction or civil engineering industry, particularly in wet utilities, is highly preferred.<\/li>\n<\/ul>\n<\/li>\n<li>\n<p><strong>Skills:<\/strong><\/p>\n<ul>\n<li>Strong knowledge of accounting principles and construction industry-specific accounting practices.<\/li>\n<li>Proficient in accounting software (e.g., QuickBooks, Procore, Viewpoint) and Microsoft Office Suite (Excel, Word, Outlook).<\/li>\n<li>Exceptional organizational skills and attention to detail.<\/li>\n<li>Excellent written and verbal communication skills.<\/li>\n<li>Strong ability to manage time effectively, prioritize tasks, and meet deadlines.<\/li>\n<\/ul>\n<\/li>\n<li>\n<p><strong>Certifications:<\/strong><\/p>\n<ul>\n<li>Certification in accounting (e.g., CPA, CMA) or payroll processing (e.g., FPC or CPP) is a plus, but not required.<\/li>\n<li>OSHA or other construction safety certifications are an added benefit.<\/li>\n<\/ul>\n<\/li>\n<li>\n<p><strong>Personal Attributes:<\/strong><\/p>\n<ul>\n<li>Ability to work independently and as part of a team.<\/li>\n<li>Strong problem-solving skills and initiative.<\/li>\n<li>High level of integrity and ability to maintain confidentiality.<\/li>\n<li>Ability to work in a fast-paced, deadline-driven environment.<\/li><\/ul><\/li><\/ul>","%category%":"Human Resources","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/c7b4248096cc-civil-construction-office-manager","%breezy_id%":"c7b4248096cc","%breezy_friendly_id%":"c7b4248096cc-civil-construction-office-manager","%breezy_created_date%":"2025-03-10T16:59:06.524Z","%breezy_updated_date%":"2025-03-10T16:59:51.139Z","%_wpgmp_location_city%":"Winchester","%_wpgmp_location_state%":"VA","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Winchester, VA, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"39.1856597","%_wpgmp_metabox_longitude%":"-78.1633341","%rank_math_internal_links_processed%":"1"}},"id":2235,"infowindow_disable":false},{"source":"post","title":"Construction Superintendent","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Construction Superintendent\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Responsibilities Our client is looking for a hard-working, dedicated Construction Superintendent with high heavy civil technical knowledge and excellent leadership&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/construction-superintendent\/\" name=\"Construction Superintendent\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Responsibilities Our client is looking for a hard-working, dedicated Construction Superintendent with high heavy civil technical knowledge and excellent leadership&hellip;","address":"Fairfax, VA, USA","location":{"lat":"38.8459879","city":"Fairfax","state":"VA","country":"United States","lng":"-77.3053035","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/construction-superintendent\/","zoom":19,"extra_fields":{"post_excerpt":"Responsibilities Our client is looking for a hard-working, dedicated Construction Superintendent with high heavy civil technical knowledge and excellent leadership&hellip;","post_content":"<p><strong>Responsibilities<\/strong><\/p>\n<p>Our client is looking for a hard-working, dedicated Construction Superintendent with high heavy civil technical knowledge and excellent leadership skills. Join our elite team of professionals building exciting, innovative infrastructure projects. With our client, you will find coworkers who are ready to collaborate and commit to working better, faster, and safer on the job. We build things that matter while providing a pathway to the American Dream. Join us and let's build excellence together. <\/p>\n<p><em>Responsibilities<\/em>: <\/p>\n<ul>\n <li>Demonstrates      technical proficiency in multiple aspects of one of the      following work processes (i.e., bridge, highway, excavation,      pipe, concrete or paving, grading, mechanical and\/or other relevant      disciplines). <\/li>\n <li>Has a      complete understanding of the plan details and specifications of assigned      projects including the estimate, man-hour budget and production      rates.  <\/li>\n <li>Plans      and organizes work to maximize potential crew productivity.      Establishes work plans and staffing plans for each phase of the      project.  Communicates performance expectations for      productivity, quality, and safety to crews and monitors progress      to ensure schedule and financial goals are met. <\/li>\n <li>Supervises field      managers for assigned projects and      plans\/schedules manpower and equipment as      needed. Mentors\/coaches field managers in leading      their crews. Maximizes equipment utilization levels      and schedules field personnel assignments.  <\/li>\n <li>Reviews      job cost with Project Manager, Field Manages and implements adjustments as      needed.   <\/li>\n <li>Follows      the Safety Program including preplanning to identify conditions      and exposures, proper safety and personal protective equipment and      accident investigation and reporting. <\/li>\n <li>Coordinates      and collaborates with Field      Managers, other Superintendents, and the customer to      implement successful project plans. Maintains professional      relationships with the owner, engineer and other members of the      construction team.  <\/li>\n <li>Inspects      construction work as necessary to ensure quality requirements and      standards are met. <\/li>\n<\/ul>\n<p><em>Reasonable accommodations may be made to enable individuals with disabilities to perform the essential functions. <\/em> <\/p>\n<p><strong>Qualifications<\/strong><\/p>\n<ul>\n <li>High      school diploma or equivalent (GED) required (equivalent work      experience will be considered) <\/li>\n <li>Bachelor\u2019s      degree in Civil Engineering, Construction Management or related      field preferred (continuing education in construction highly      desirable) <\/li>\n <li>Minimum      6 years of heavy civil construction experience with at least 2      years of Superintendent experience required <\/li>\n <li>Experience      in multiple trade disciplines preferred <\/li>\n <li>OSHA 30      hour certification required (those not having this      credential must certify or be enrolled in a certification course within 6      months of hire\/promotion) <\/li>\n <li>Valid      driver\u2019s license required<\/li>\n<\/ul>","post_title":"Construction Superintendent","post_link":"https:\/\/turnerstaffing.com\/position\/construction-superintendent\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"","%location_country%":"United States","%location_city%":"Fairfax","%location_state_id%":"VA","%location_state_name%":"Virginia","%location_city_state%":"Fairfax, VA","%education%":"","%department%":"","%description%":"<p><strong>Responsibilities<\/strong><\/p>\n<p>Our client is looking for a hard-working, dedicated Construction Superintendent with high heavy civil technical knowledge and excellent leadership skills. Join our elite team of professionals building exciting, innovative infrastructure projects. With our client, you will find coworkers who are ready to collaborate and commit to working better, faster, and safer on the job. We build things that matter while providing a pathway to the American Dream. Join us and let's build excellence together. <\/p>\n<p><em>Responsibilities<\/em>: <\/p>\n<ul>\n <li>Demonstrates      technical proficiency in multiple aspects of one of the      following work processes (i.e., bridge, highway, excavation,      pipe, concrete or paving, grading, mechanical and\/or other relevant      disciplines). <\/li>\n <li>Has a      complete understanding of the plan details and specifications of assigned      projects including the estimate, man-hour budget and production      rates.  <\/li>\n <li>Plans      and organizes work to maximize potential crew productivity.      Establishes work plans and staffing plans for each phase of the      project.  Communicates performance expectations for      productivity, quality, and safety to crews and monitors progress      to ensure schedule and financial goals are met. <\/li>\n <li>Supervises field      managers for assigned projects and      plans\/schedules manpower and equipment as      needed. Mentors\/coaches field managers in leading      their crews. Maximizes equipment utilization levels      and schedules field personnel assignments.  <\/li>\n <li>Reviews      job cost with Project Manager, Field Manages and implements adjustments as      needed.   <\/li>\n <li>Follows      the Safety Program including preplanning to identify conditions      and exposures, proper safety and personal protective equipment and      accident investigation and reporting. <\/li>\n <li>Coordinates      and collaborates with Field      Managers, other Superintendents, and the customer to      implement successful project plans. Maintains professional      relationships with the owner, engineer and other members of the      construction team.  <\/li>\n <li>Inspects      construction work as necessary to ensure quality requirements and      standards are met. <\/li>\n<\/ul>\n<p><em>Reasonable accommodations may be made to enable individuals with disabilities to perform the essential functions. <\/em> <\/p>\n<p><strong>Qualifications<\/strong><\/p>\n<ul>\n <li>High      school diploma or equivalent (GED) required (equivalent work      experience will be considered) <\/li>\n <li>Bachelor\u2019s      degree in Civil Engineering, Construction Management or related      field preferred (continuing education in construction highly      desirable) <\/li>\n <li>Minimum      6 years of heavy civil construction experience with at least 2      years of Superintendent experience required <\/li>\n <li>Experience      in multiple trade disciplines preferred <\/li>\n <li>OSHA 30      hour certification required (those not having this      credential must certify or be enrolled in a certification course within 6      months of hire\/promotion) <\/li>\n <li>Valid      driver\u2019s license required<\/li>\n<\/ul>","%category%":"","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/02a6d86f5a51-construction-superintendent","%breezy_id%":"02a6d86f5a51","%breezy_friendly_id%":"02a6d86f5a51-construction-superintendent","%breezy_created_date%":"2025-03-10T15:24:40.985Z","%breezy_updated_date%":"2025-03-10T15:26:16.685Z","%_wpgmp_location_city%":"Fairfax","%_wpgmp_location_state%":"VA","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Fairfax, VA, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"38.8459879","%_wpgmp_metabox_longitude%":"-77.3053035","%rank_math_internal_links_processed%":"1"}},"id":2232,"infowindow_disable":false},{"source":"post","title":"Heavy Equipment Operator","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Heavy Equipment Operator\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Position Overview: We are seeking an experienced and safety-conscious Heavy Equipment Operator to join our team in the Winchester, VA&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/heavy-equipment-operator-4\/\" name=\"Heavy Equipment Operator\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Position Overview: We are seeking an experienced and safety-conscious Heavy Equipment Operator to join our team in the Winchester, VA&hellip;","address":"Winchester, VA, USA","location":{"lat":"39.1856597","city":"Winchester","state":"VA","country":"United States","lng":"-78.1633341","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/heavy-equipment-operator-4\/","zoom":19,"extra_fields":{"post_excerpt":"Position Overview: We are seeking an experienced and safety-conscious Heavy Equipment Operator to join our team in the Winchester, VA&hellip;","post_content":"<p><strong>Position Overview:<\/strong><br>\nWe are seeking an experienced and safety-conscious Heavy Equipment Operator to join our team in the Winchester, VA area. This role will be responsible for operating D6 Dozers and 352 Excavators in the wet utilities sector of civil construction. The ideal candidate will have a strong background in operating heavy equipment, particularly in the excavation and earthmoving aspects of utility installation, trenching, and site preparation.<\/p>\n<p><strong>Key Responsibilities:<\/strong><\/p>\n<ul>\n<li><strong>Operate Heavy Equipment:<\/strong> Efficiently and safely operate D6 Dozers and 352 Excavators for grading, digging, trenching, and excavation tasks in the wet utilities civil construction environment.<\/li>\n<li><strong>Excavation &amp; Site Preparation:<\/strong> Perform excavation duties for utility installation, including digging trenches for water, sewer, stormwater, and other underground utilities.<\/li>\n<li><strong>Material Handling:<\/strong> Load, move, and place materials such as soil, gravel, and rocks using the dozer and excavator.<\/li>\n<li><strong>Follow Plans &amp; Specifications:<\/strong> Work closely with project managers and site supervisors to ensure operations follow blueprints, design plans, and regulatory requirements.<\/li>\n<li><strong>Safety Compliance:<\/strong> Adhere to all safety protocols and regulations to maintain a safe work environment. Perform daily inspections of equipment and perform minor maintenance as needed.<\/li>\n<li><strong>Site Coordination:<\/strong> Work with other operators, laborers, and supervisors to maintain the efficiency and effectiveness of daily operations.<\/li>\n<li><strong>Routine Maintenance:<\/strong> Conduct routine equipment checks, report any mechanical issues, and assist with minor repairs or maintenance on machines.<\/li>\n<li><strong>Environmental Considerations:<\/strong> Ensure environmental regulations and best practices are followed, especially when working near water sources or sensitive areas.<\/li>\n<\/ul>\n<p><strong>Qualifications:<\/strong><\/p>\n<ul>\n<li><strong>Experience:<\/strong> Minimum of 3-5 years of experience in operating heavy equipment, specifically D6 Dozers and 352 Excavators, in a civil construction or wet utilities environment.<\/li>\n<li><strong>Certifications:<\/strong> Valid heavy equipment operator certification or equivalent training. OSHA or other relevant safety training is a plus.<\/li>\n<li><strong>Knowledge:<\/strong> Strong understanding of civil construction practices, wet utilities installation, and safety regulations.<\/li>\n<li><strong>Physical Requirements:<\/strong> Ability to work in outdoor environments, including inclement weather conditions. Must be able to lift heavy materials and work in physically demanding conditions.<\/li>\n<li><strong>Skills:<\/strong> Excellent hand-eye coordination, good mechanical aptitude, and ability to operate equipment safely and efficiently.<\/li>\n<li><strong>Communication:<\/strong> Strong communication skills, both verbal and written, for effective collaboration with team members and supervisors.<\/li>\n<li><strong>Driver\u2019s License:<\/strong> Valid driver\u2019s license with a clean driving record. CDL is a plus but not required.<\/li><\/ul>","post_title":"Heavy Equipment Operator","post_link":"https:\/\/turnerstaffing.com\/position\/heavy-equipment-operator-4\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Mid Level","%location_country%":"United States","%location_city%":"Winchester","%location_state_id%":"VA","%location_state_name%":"Virginia","%location_city_state%":"Winchester, VA","%education%":"Unspecified","%department%":"","%description%":"<p><strong>Position Overview:<\/strong><br>\nWe are seeking an experienced and safety-conscious Heavy Equipment Operator to join our team in the Winchester, VA area. This role will be responsible for operating D6 Dozers and 352 Excavators in the wet utilities sector of civil construction. The ideal candidate will have a strong background in operating heavy equipment, particularly in the excavation and earthmoving aspects of utility installation, trenching, and site preparation.<\/p>\n<p><strong>Key Responsibilities:<\/strong><\/p>\n<ul>\n<li><strong>Operate Heavy Equipment:<\/strong> Efficiently and safely operate D6 Dozers and 352 Excavators for grading, digging, trenching, and excavation tasks in the wet utilities civil construction environment.<\/li>\n<li><strong>Excavation &amp; Site Preparation:<\/strong> Perform excavation duties for utility installation, including digging trenches for water, sewer, stormwater, and other underground utilities.<\/li>\n<li><strong>Material Handling:<\/strong> Load, move, and place materials such as soil, gravel, and rocks using the dozer and excavator.<\/li>\n<li><strong>Follow Plans &amp; Specifications:<\/strong> Work closely with project managers and site supervisors to ensure operations follow blueprints, design plans, and regulatory requirements.<\/li>\n<li><strong>Safety Compliance:<\/strong> Adhere to all safety protocols and regulations to maintain a safe work environment. Perform daily inspections of equipment and perform minor maintenance as needed.<\/li>\n<li><strong>Site Coordination:<\/strong> Work with other operators, laborers, and supervisors to maintain the efficiency and effectiveness of daily operations.<\/li>\n<li><strong>Routine Maintenance:<\/strong> Conduct routine equipment checks, report any mechanical issues, and assist with minor repairs or maintenance on machines.<\/li>\n<li><strong>Environmental Considerations:<\/strong> Ensure environmental regulations and best practices are followed, especially when working near water sources or sensitive areas.<\/li>\n<\/ul>\n<p><strong>Qualifications:<\/strong><\/p>\n<ul>\n<li><strong>Experience:<\/strong> Minimum of 3-5 years of experience in operating heavy equipment, specifically D6 Dozers and 352 Excavators, in a civil construction or wet utilities environment.<\/li>\n<li><strong>Certifications:<\/strong> Valid heavy equipment operator certification or equivalent training. OSHA or other relevant safety training is a plus.<\/li>\n<li><strong>Knowledge:<\/strong> Strong understanding of civil construction practices, wet utilities installation, and safety regulations.<\/li>\n<li><strong>Physical Requirements:<\/strong> Ability to work in outdoor environments, including inclement weather conditions. Must be able to lift heavy materials and work in physically demanding conditions.<\/li>\n<li><strong>Skills:<\/strong> Excellent hand-eye coordination, good mechanical aptitude, and ability to operate equipment safely and efficiently.<\/li>\n<li><strong>Communication:<\/strong> Strong communication skills, both verbal and written, for effective collaboration with team members and supervisors.<\/li>\n<li><strong>Driver\u2019s License:<\/strong> Valid driver\u2019s license with a clean driving record. CDL is a plus but not required.<\/li><\/ul>","%category%":"Operations","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/9f51d8b20520-heavy-equipment-operator","%breezy_id%":"9f51d8b20520","%breezy_friendly_id%":"9f51d8b20520-heavy-equipment-operator","%breezy_created_date%":"2025-03-10T16:51:30.607Z","%breezy_updated_date%":"2025-03-10T16:52:20.712Z","%_wpgmp_location_city%":"Winchester","%_wpgmp_location_state%":"VA","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Winchester, VA, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"39.1856597","%_wpgmp_metabox_longitude%":"-78.1633341","%rank_math_internal_links_processed%":"1"}},"id":2233,"infowindow_disable":false},{"source":"post","title":"Heavy Equipment Fuel Lube Technician","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Heavy Equipment Fuel Lube Technician\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    About Us:Turner Staffing Group, in collaboration with our esteemed mining partner in Kershaw, South Carolina, is actively seeking experienced maintenance&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/heavy-equipment-fuel-lube-technician\/\" name=\"Heavy Equipment Fuel Lube Technician\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"About Us:Turner Staffing Group, in collaboration with our esteemed mining partner in Kershaw, South Carolina, is actively seeking experienced maintenance&hellip;","address":"Kershaw, SC, USA","location":{"lat":"34.5518201","city":"Kershaw","state":"SC","country":"United States","lng":"-80.5836836","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/heavy-equipment-fuel-lube-technician\/","zoom":19,"extra_fields":{"post_excerpt":"About Us:Turner Staffing Group, in collaboration with our esteemed mining partner in Kershaw, South Carolina, is actively seeking experienced maintenance&hellip;","post_content":"<p><strong>About Us:<\/strong><br>Turner Staffing Group, in collaboration with our esteemed mining partner in Kershaw, South Carolina, is actively seeking experienced maintenance professionals to join our dynamic team. As a leading force in the mining industry, we are dedicated to fostering a culture of excellence, safety, and innovation.<br><\/p>\n<p>We are looking for a dynamic and talented professional to fill a&nbsp;<strong>Fuel &amp; Lube Technician<\/strong>&nbsp;role at our fast-growing, forward thinking mining services company.<\/p>\n<p>This person will function as a&nbsp;<strong>Fuel &amp; Lube Technician<\/strong> and must be willing to do, learn, perform and improve any maintenance task. Tasks will be defined and evolve in all areas of mining operations to ensure preventative maintenance is practiced, repairs, equipment runs in the area of responsibility. This is an opportunity to work as part of the operations team in a safe, productive, and fun environment.<\/p>\n<p><strong>Essential Skills &amp; Knowledge<\/strong><\/p>\n<p>\u2022 Follow a consistent and regular schedule to perform various types of maintenance on heavy equipment and various pieces of machinery&nbsp;<\/p>\n<p>\u2022 Perform minor repairs on equipment using tools, machine tools and measuring instruments&nbsp;<\/p>\n<p>\u2022 Conduct oil changes, lubrication of equipment, tire replacements, hose repairs, battery replacements and assorted services&nbsp;<\/p>\n<p>\u2022 Operate and test equipment&nbsp;<\/p>\n<p>\u2022 Produce detailed service reports and repair logs&nbsp;<\/p>\n<p>\u2022 Follow all established procedures and protocols&nbsp;<\/p>\n<p>\u2022 Build positive relationships with internal and external teams<\/p>\n<p>\u2022 Perform additional duties as assigned<\/p>","post_title":"Heavy Equipment Fuel Lube Technician","post_link":"https:\/\/turnerstaffing.com\/position\/heavy-equipment-fuel-lube-technician\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"","%location_country%":"United States","%location_city%":"Kershaw","%location_state_id%":"SC","%location_state_name%":"South Carolina","%location_city_state%":"Kershaw, SC","%education%":"","%department%":"","%description%":"<p><strong>About Us:<\/strong><br>Turner Staffing Group, in collaboration with our esteemed mining partner in Kershaw, South Carolina, is actively seeking experienced maintenance professionals to join our dynamic team. As a leading force in the mining industry, we are dedicated to fostering a culture of excellence, safety, and innovation.<br><\/p>\n<p>We are looking for a dynamic and talented professional to fill a&nbsp;<strong>Fuel &amp; Lube Technician<\/strong>&nbsp;role at our fast-growing, forward thinking mining services company.<\/p>\n<p>This person will function as a&nbsp;<strong>Fuel &amp; Lube Technician<\/strong> and must be willing to do, learn, perform and improve any maintenance task. Tasks will be defined and evolve in all areas of mining operations to ensure preventative maintenance is practiced, repairs, equipment runs in the area of responsibility. This is an opportunity to work as part of the operations team in a safe, productive, and fun environment.<\/p>\n<p><strong>Essential Skills &amp; Knowledge<\/strong><\/p>\n<p>\u2022 Follow a consistent and regular schedule to perform various types of maintenance on heavy equipment and various pieces of machinery&nbsp;<\/p>\n<p>\u2022 Perform minor repairs on equipment using tools, machine tools and measuring instruments&nbsp;<\/p>\n<p>\u2022 Conduct oil changes, lubrication of equipment, tire replacements, hose repairs, battery replacements and assorted services&nbsp;<\/p>\n<p>\u2022 Operate and test equipment&nbsp;<\/p>\n<p>\u2022 Produce detailed service reports and repair logs&nbsp;<\/p>\n<p>\u2022 Follow all established procedures and protocols&nbsp;<\/p>\n<p>\u2022 Build positive relationships with internal and external teams<\/p>\n<p>\u2022 Perform additional duties as assigned<\/p>","%category%":"","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/87de073f2f25-heavy-equipment-fuel-lube-technician","%breezy_id%":"87de073f2f25","%breezy_friendly_id%":"87de073f2f25-heavy-equipment-fuel-lube-technician","%breezy_created_date%":"2025-02-04T21:47:40.868Z","%breezy_updated_date%":"2025-03-05T14:22:29.008Z","%_wpgmp_location_city%":"Kershaw","%_wpgmp_location_state%":"SC","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Kershaw, SC, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"34.5518201","%_wpgmp_metabox_longitude%":"-80.5836836","%rank_math_internal_links_processed%":"1"}},"id":2221,"infowindow_disable":false},{"source":"post","title":"Loader Operator","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Loader Operator\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Production Loader Operator Company: Turner Staffing Group (Partnered with a Local Mining Company) Position Type: Full-Time Salary: Competitive, based on&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/loader-operator\/\" name=\"Loader Operator\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Production Loader Operator Company: Turner Staffing Group (Partnered with a Local Mining Company) Position Type: Full-Time Salary: Competitive, based on&hellip;","address":"Kershaw, SC, USA","location":{"lat":"34.5518201","city":"Kershaw","state":"SC","country":"United States","lng":"-80.5836836","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/loader-operator\/","zoom":19,"extra_fields":{"post_excerpt":"Production Loader Operator Company: Turner Staffing Group (Partnered with a Local Mining Company) Position Type: Full-Time Salary: Competitive, based on&hellip;","post_content":"<p><strong><u>Production Loader Operator<\/u><\/strong><\/p><p><strong>Company:<\/strong> Turner Staffing Group (Partnered with a Local Mining Company)<\/p>\n<p><strong>Position Type:<\/strong> Full-Time<\/p>\n<p><strong>Salary:<\/strong> Competitive, based on experience<\/p>\n<h4>Job Overview:<\/h4>\n<p>Turner Staffing Group is seeking a skilled Production Loader Operator to join our partner\u2019s mining team in Kershaw, South Carolina. The ideal candidate will have experience operating loaders in a mining environment and a strong understanding of mining production processes. This role involves operating heavy equipment to move materials, load trucks, and support overall production activities.<\/p>\n<h4>Key Responsibilities:<\/h4>\n<ul><li>Operate production loaders to move, load, and handle materials such as ore, rock, and other mined materials.<\/li><li>Perform pre-operational checks and regular maintenance on loaders to ensure safety and functionality.<\/li><li>Work closely with other operators and team members to coordinate production activities.<\/li><li>Maintain a clean and organized work environment around the loading area.<\/li><li>Follow safety guidelines and company policies to ensure a safe work environment.<\/li><li>Monitor equipment performance and report any issues or necessary repairs to maintenance personnel.<\/li><li>Maintain accurate records of material movements and loader usage.<\/li><li>Assist with other mining operations and tasks as needed.<\/li><\/ul>\n<h4>Qualifications:<\/h4>\n<ul><li>High school diploma or equivalent.<\/li><li>Proven experience as a loader operator, preferably in a mining environment.<\/li><li>Strong knowledge of loader operations, safety practices, and basic maintenance.<\/li><li>Ability to read and interpret production schedules and work instructions.<\/li><li>Good physical condition with the ability to work in various weather conditions.<\/li><li>Strong communication and teamwork skills.<\/li><li>Attention to detail and commitment to safety.<\/li><li>Valid driver\u2019s license and reliable transportation.<\/li><\/ul>\n<h4>Preferred Qualifications:<\/h4>\n<ul><li>Experience in metal mining or a similar heavy industry.<\/li><li>Certification or training in loader operation.<\/li><li>Familiarity with mining production processes and equipment.<\/li><\/ul>\n<h4>Benefits:<\/h4>\n<ul><li>Competitive salary and comprehensive benefits package.<\/li><li>Opportunities for professional growth and advancement.<\/li><li>Health, dental, and vision insurance.<\/li><li>Retirement savings plan with company match.<\/li><li>Supportive and inclusive work environment.<\/li><\/ul><p><strong><u><br><\/u><\/strong><\/p>","post_title":"Loader Operator","post_link":"https:\/\/turnerstaffing.com\/position\/loader-operator\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Associate","%location_country%":"United States","%location_city%":"Kershaw","%location_state_id%":"SC","%location_state_name%":"South Carolina","%location_city_state%":"Kershaw, SC","%education%":"Unspecified","%department%":"Operations","%description%":"<p><strong><u>Production Loader Operator<\/u><\/strong><\/p><p><strong>Company:<\/strong> Turner Staffing Group (Partnered with a Local Mining Company)<\/p>\n<p><strong>Position Type:<\/strong> Full-Time<\/p>\n<p><strong>Salary:<\/strong> Competitive, based on experience<\/p>\n<h4>Job Overview:<\/h4>\n<p>Turner Staffing Group is seeking a skilled Production Loader Operator to join our partner\u2019s mining team in Kershaw, South Carolina. The ideal candidate will have experience operating loaders in a mining environment and a strong understanding of mining production processes. This role involves operating heavy equipment to move materials, load trucks, and support overall production activities.<\/p>\n<h4>Key Responsibilities:<\/h4>\n<ul><li>Operate production loaders to move, load, and handle materials such as ore, rock, and other mined materials.<\/li><li>Perform pre-operational checks and regular maintenance on loaders to ensure safety and functionality.<\/li><li>Work closely with other operators and team members to coordinate production activities.<\/li><li>Maintain a clean and organized work environment around the loading area.<\/li><li>Follow safety guidelines and company policies to ensure a safe work environment.<\/li><li>Monitor equipment performance and report any issues or necessary repairs to maintenance personnel.<\/li><li>Maintain accurate records of material movements and loader usage.<\/li><li>Assist with other mining operations and tasks as needed.<\/li><\/ul>\n<h4>Qualifications:<\/h4>\n<ul><li>High school diploma or equivalent.<\/li><li>Proven experience as a loader operator, preferably in a mining environment.<\/li><li>Strong knowledge of loader operations, safety practices, and basic maintenance.<\/li><li>Ability to read and interpret production schedules and work instructions.<\/li><li>Good physical condition with the ability to work in various weather conditions.<\/li><li>Strong communication and teamwork skills.<\/li><li>Attention to detail and commitment to safety.<\/li><li>Valid driver\u2019s license and reliable transportation.<\/li><\/ul>\n<h4>Preferred Qualifications:<\/h4>\n<ul><li>Experience in metal mining or a similar heavy industry.<\/li><li>Certification or training in loader operation.<\/li><li>Familiarity with mining production processes and equipment.<\/li><\/ul>\n<h4>Benefits:<\/h4>\n<ul><li>Competitive salary and comprehensive benefits package.<\/li><li>Opportunities for professional growth and advancement.<\/li><li>Health, dental, and vision insurance.<\/li><li>Retirement savings plan with company match.<\/li><li>Supportive and inclusive work environment.<\/li><\/ul><p><strong><u><br><\/u><\/strong><\/p>","%category%":"Operations","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/911905533756-loader-operator","%breezy_id%":"911905533756","%breezy_friendly_id%":"911905533756-loader-operator","%breezy_created_date%":"2024-08-27T13:55:50.627Z","%breezy_updated_date%":"2025-03-05T14:22:23.601Z","%_wpgmp_location_city%":"Kershaw","%_wpgmp_location_state%":"SC","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Kershaw, SC, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"34.5518201","%_wpgmp_metabox_longitude%":"-80.5836836","%rank_math_internal_links_processed%":"1"}},"id":2220,"infowindow_disable":false},{"source":"post","title":"Excavator Operator","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Excavator Operator\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Job Title: Excavator Operator Location: Kershaw, South Carolina About Us: Turner Staffing Group is a leading staffing agency dedicated to&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/excavator-operator\/\" name=\"Excavator Operator\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Job Title: Excavator Operator Location: Kershaw, South Carolina About Us: Turner Staffing Group is a leading staffing agency dedicated to&hellip;","address":"Kershaw, SC, USA","location":{"lat":"34.5518201","city":"Kershaw","state":"SC","country":"United States","lng":"-80.5836836","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/excavator-operator\/","zoom":19,"extra_fields":{"post_excerpt":"Job Title: Excavator Operator Location: Kershaw, South Carolina About Us: Turner Staffing Group is a leading staffing agency dedicated to&hellip;","post_content":"<p><strong>Job Title: Excavator Operator<\/strong><br><\/p>\n<p><strong>Location:<\/strong> Kershaw, South Carolina<\/p>\n<p><strong>About Us:<\/strong>\nTurner Staffing Group is a leading staffing agency dedicated to connecting skilled professionals with rewarding opportunities. We are proud to partner with a reputable mining company located in Kershaw, South Carolina. Our client is seeking a skilled and experienced Excavator Operator to join their team and contribute to their ongoing success in the mining industry.<\/p>\n<p><strong>Job Description:<\/strong><\/p>\n<p>As an Excavator Operator, you will play a critical role in the efficient operation of our mining operations in Kershaw, South Carolina. Operating heavy equipment with precision and safety, you will be responsible for excavating and moving materials to facilitate mining activities and achieve production targets.<\/p>\n<p><strong>Key Responsibilities:<\/strong><\/p>\n<ol><li><strong>Equipment Operation:<\/strong> Operate hydraulic excavators with precision and efficiency to excavate, load, and transport materials within the mining site. Familiarity with various excavator attachments and equipment configurations is preferred.<\/li><li><strong>Safety Compliance:<\/strong> Adhere to all safety protocols and procedures to ensure a safe working environment for yourself and others. Conduct pre-operation inspections and routine maintenance checks on equipment to identify and address any safety hazards or mechanical issues.<\/li><li><strong>Material Handling:<\/strong> Utilize excavators to move, load, and unload materials such as overburden, ore, and waste rock. Coordinate with other team members to optimize material handling processes and minimize downtime.<\/li><li><strong>Production Support:<\/strong> Support mining operations by excavating trenches, stockpiling materials, and shaping terrain as required. Work collaboratively with supervisors and other operators to achieve production targets and meet project deadlines.<\/li><li><strong>Quality Control:<\/strong> Maintain a high level of accuracy and precision in material handling activities to ensure the quality and integrity of mined materials. Follow established procedures for separating and stockpiling different grades of materials as required.<\/li><li><strong>Equipment Maintenance:<\/strong> Perform routine maintenance tasks on excavators, including greasing, lubricating, and replacing worn parts. Report any mechanical issues or equipment malfunctions to the maintenance team for timely repairs.<\/li><\/ol>\n<p><strong>Qualifications:<\/strong><\/p>\n<ul><li>Previous experience operating hydraulic excavators in a mining or heavy construction environment is required.<\/li><li>Proficiency in operating excavators with precision and accuracy, including the ability to manipulate attachments and control machine functions effectively.<\/li><li>Strong commitment to safety and adherence to safety regulations and best practices.<\/li><li>Mechanical aptitude and the ability to perform routine maintenance tasks on equipment.<\/li><li>Excellent hand-eye coordination, spatial awareness, and depth perception.<\/li><li>Willingness to work outdoors in various weather conditions and physically demanding environments.<\/li><\/ul>","post_title":"Excavator Operator","post_link":"https:\/\/turnerstaffing.com\/position\/excavator-operator\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Associate","%location_country%":"United States","%location_city%":"Kershaw","%location_state_id%":"SC","%location_state_name%":"South Carolina","%location_city_state%":"Kershaw, SC","%education%":"High School or equivalent","%department%":"Operations","%description%":"<p><strong>Job Title: Excavator Operator<\/strong><br><\/p>\n<p><strong>Location:<\/strong> Kershaw, South Carolina<\/p>\n<p><strong>About Us:<\/strong>\nTurner Staffing Group is a leading staffing agency dedicated to connecting skilled professionals with rewarding opportunities. We are proud to partner with a reputable mining company located in Kershaw, South Carolina. Our client is seeking a skilled and experienced Excavator Operator to join their team and contribute to their ongoing success in the mining industry.<\/p>\n<p><strong>Job Description:<\/strong><\/p>\n<p>As an Excavator Operator, you will play a critical role in the efficient operation of our mining operations in Kershaw, South Carolina. Operating heavy equipment with precision and safety, you will be responsible for excavating and moving materials to facilitate mining activities and achieve production targets.<\/p>\n<p><strong>Key Responsibilities:<\/strong><\/p>\n<ol><li><strong>Equipment Operation:<\/strong> Operate hydraulic excavators with precision and efficiency to excavate, load, and transport materials within the mining site. Familiarity with various excavator attachments and equipment configurations is preferred.<\/li><li><strong>Safety Compliance:<\/strong> Adhere to all safety protocols and procedures to ensure a safe working environment for yourself and others. Conduct pre-operation inspections and routine maintenance checks on equipment to identify and address any safety hazards or mechanical issues.<\/li><li><strong>Material Handling:<\/strong> Utilize excavators to move, load, and unload materials such as overburden, ore, and waste rock. Coordinate with other team members to optimize material handling processes and minimize downtime.<\/li><li><strong>Production Support:<\/strong> Support mining operations by excavating trenches, stockpiling materials, and shaping terrain as required. Work collaboratively with supervisors and other operators to achieve production targets and meet project deadlines.<\/li><li><strong>Quality Control:<\/strong> Maintain a high level of accuracy and precision in material handling activities to ensure the quality and integrity of mined materials. Follow established procedures for separating and stockpiling different grades of materials as required.<\/li><li><strong>Equipment Maintenance:<\/strong> Perform routine maintenance tasks on excavators, including greasing, lubricating, and replacing worn parts. Report any mechanical issues or equipment malfunctions to the maintenance team for timely repairs.<\/li><\/ol>\n<p><strong>Qualifications:<\/strong><\/p>\n<ul><li>Previous experience operating hydraulic excavators in a mining or heavy construction environment is required.<\/li><li>Proficiency in operating excavators with precision and accuracy, including the ability to manipulate attachments and control machine functions effectively.<\/li><li>Strong commitment to safety and adherence to safety regulations and best practices.<\/li><li>Mechanical aptitude and the ability to perform routine maintenance tasks on equipment.<\/li><li>Excellent hand-eye coordination, spatial awareness, and depth perception.<\/li><li>Willingness to work outdoors in various weather conditions and physically demanding environments.<\/li><\/ul>","%category%":"Operations","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/99547b2c6f0d-excavator-operator","%breezy_id%":"99547b2c6f0d","%breezy_friendly_id%":"99547b2c6f0d-excavator-operator","%breezy_created_date%":"2024-04-10T20:48:53.746Z","%breezy_updated_date%":"2025-03-05T14:22:08.797Z","%_wpgmp_location_city%":"Kershaw","%_wpgmp_location_state%":"SC","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Kershaw, SC, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"34.5518201","%_wpgmp_metabox_longitude%":"-80.5836836","%rank_math_internal_links_processed%":"1"}},"id":2218,"infowindow_disable":false},{"source":"post","title":"Heavy Equipment Operator","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Heavy Equipment Operator\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Job Title: Heavy Equipment Operator Company: Turner Staffing Group Location: Kershaw, South Carolina, USA Position Type: Full-Time About Us: Turner&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/heavy-equipment-operator\/\" name=\"Heavy Equipment Operator\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Job Title: Heavy Equipment Operator Company: Turner Staffing Group Location: Kershaw, South Carolina, USA Position Type: Full-Time About Us: Turner&hellip;","address":"Kershaw, SC, USA","location":{"lat":"34.5518201","city":"Kershaw","state":"SC","country":"United States","lng":"-80.5836836","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/heavy-equipment-operator\/","zoom":19,"extra_fields":{"post_excerpt":"Job Title: Heavy Equipment Operator Company: Turner Staffing Group Location: Kershaw, South Carolina, USA Position Type: Full-Time About Us: Turner&hellip;","post_content":"<p><strong>Job Title:<\/strong> Heavy Equipment Operator<\/p>\n<p><strong>Company:<\/strong> Turner Staffing Group<\/p>\n<p><strong>Location:<\/strong> Kershaw, South Carolina, USA<\/p>\n<p><strong>Position Type:<\/strong> Full-Time<\/p>\n<p><strong>About Us:<\/strong>\nTurner Staffing Group, in collaboration with our esteemed mining partner in Kershaw, South Carolina, is actively seeking experienced Heavy Equipment Operators to join our dynamic team. As a leading force in the mining industry, we are dedicated to fostering a culture of excellence, safety, and innovation.<\/p>\n<p><strong>Job Overview:<\/strong>\nWe are looking for skilled and safety-conscious Heavy Equipment Operators to contribute to the success of our mining operations. The ideal candidates will have hands-on experience operating a variety of heavy equipment, ensuring the efficient and safe extraction of minerals from the site.<\/p>\n<p><strong>Responsibilities:<\/strong><\/p>\n<ol><li><strong>Equipment Operation:<\/strong><ul><li>Safely operate heavy equipment, including but not limited to bulldozers, excavators, loaders, and haul trucks.<\/li><li>Execute tasks such as grading, digging, loading, and transporting materials as per project requirements.<\/li><\/ul><\/li><li><strong>Safety Compliance:<\/strong><ul><li>Adhere to all safety protocols and guidelines to ensure a secure work environment.<\/li><li>Conduct routine equipment inspections and report any issues promptly.<\/li><\/ul><\/li><li><strong>Efficiency and Productivity:<\/strong><ul><li>Work collaboratively with the mining team to optimize workflow and maximize production efficiency.<\/li><li>Meet project deadlines and production targets while maintaining high-quality standards.<\/li><\/ul><\/li><li><strong>Communication:<\/strong><ul><li>Effectively communicate with supervisors, colleagues, and other team members to ensure seamless project coordination.<\/li><li>Report any operational challenges or concerns in a timely manner.<\/li><\/ul><\/li><li><strong>Maintenance Support:<\/strong><ul><li>Collaborate with the maintenance team to facilitate regular equipment maintenance and repairs.<\/li><li>Assist in troubleshooting equipment issues and participate in scheduled maintenance activities.<\/li><\/ul><\/li><\/ol>\n<p><strong>Requirements:<\/strong><\/p>\n<ul><li>Proven experience as a Heavy Equipment Operator in a mining or similar industry.<\/li><li>Familiarity with safety regulations and commitment to safe work practices.<\/li><li>Ability to operate various heavy equipment efficiently and skillfully.<\/li><li>Strong communication and teamwork skills.<\/li><\/ul>\n<p><strong>Education and Certifications:<\/strong><\/p>\n<ul><li>High school diploma or equivalent.<\/li><li>Relevant certifications for heavy equipment operation.<\/li><li>MSHA experience preferred.&nbsp;<\/li><\/ul>\n<p><strong>Benefits:<\/strong><\/p>\n<ul><li>Competitive salary<\/li><li>Health, dental, and vision insurance<\/li><li>Retirement savings plan<\/li><\/ul>","post_title":"Heavy Equipment Operator","post_link":"https:\/\/turnerstaffing.com\/position\/heavy-equipment-operator\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Associate","%location_country%":"United States","%location_city%":"Kershaw","%location_state_id%":"SC","%location_state_name%":"South Carolina","%location_city_state%":"Kershaw, SC","%education%":"High School or equivalent","%department%":"Operations","%description%":"<p><strong>Job Title:<\/strong> Heavy Equipment Operator<\/p>\n<p><strong>Company:<\/strong> Turner Staffing Group<\/p>\n<p><strong>Location:<\/strong> Kershaw, South Carolina, USA<\/p>\n<p><strong>Position Type:<\/strong> Full-Time<\/p>\n<p><strong>About Us:<\/strong>\nTurner Staffing Group, in collaboration with our esteemed mining partner in Kershaw, South Carolina, is actively seeking experienced Heavy Equipment Operators to join our dynamic team. As a leading force in the mining industry, we are dedicated to fostering a culture of excellence, safety, and innovation.<\/p>\n<p><strong>Job Overview:<\/strong>\nWe are looking for skilled and safety-conscious Heavy Equipment Operators to contribute to the success of our mining operations. The ideal candidates will have hands-on experience operating a variety of heavy equipment, ensuring the efficient and safe extraction of minerals from the site.<\/p>\n<p><strong>Responsibilities:<\/strong><\/p>\n<ol><li><strong>Equipment Operation:<\/strong><ul><li>Safely operate heavy equipment, including but not limited to bulldozers, excavators, loaders, and haul trucks.<\/li><li>Execute tasks such as grading, digging, loading, and transporting materials as per project requirements.<\/li><\/ul><\/li><li><strong>Safety Compliance:<\/strong><ul><li>Adhere to all safety protocols and guidelines to ensure a secure work environment.<\/li><li>Conduct routine equipment inspections and report any issues promptly.<\/li><\/ul><\/li><li><strong>Efficiency and Productivity:<\/strong><ul><li>Work collaboratively with the mining team to optimize workflow and maximize production efficiency.<\/li><li>Meet project deadlines and production targets while maintaining high-quality standards.<\/li><\/ul><\/li><li><strong>Communication:<\/strong><ul><li>Effectively communicate with supervisors, colleagues, and other team members to ensure seamless project coordination.<\/li><li>Report any operational challenges or concerns in a timely manner.<\/li><\/ul><\/li><li><strong>Maintenance Support:<\/strong><ul><li>Collaborate with the maintenance team to facilitate regular equipment maintenance and repairs.<\/li><li>Assist in troubleshooting equipment issues and participate in scheduled maintenance activities.<\/li><\/ul><\/li><\/ol>\n<p><strong>Requirements:<\/strong><\/p>\n<ul><li>Proven experience as a Heavy Equipment Operator in a mining or similar industry.<\/li><li>Familiarity with safety regulations and commitment to safe work practices.<\/li><li>Ability to operate various heavy equipment efficiently and skillfully.<\/li><li>Strong communication and teamwork skills.<\/li><\/ul>\n<p><strong>Education and Certifications:<\/strong><\/p>\n<ul><li>High school diploma or equivalent.<\/li><li>Relevant certifications for heavy equipment operation.<\/li><li>MSHA experience preferred.&nbsp;<\/li><\/ul>\n<p><strong>Benefits:<\/strong><\/p>\n<ul><li>Competitive salary<\/li><li>Health, dental, and vision insurance<\/li><li>Retirement savings plan<\/li><\/ul>","%category%":"Operations","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/069e55e8d946-heavy-equipment-operator","%breezy_id%":"069e55e8d946","%breezy_friendly_id%":"069e55e8d946-heavy-equipment-operator","%breezy_created_date%":"2024-02-28T15:16:25.397Z","%breezy_updated_date%":"2025-03-05T14:22:20.200Z","%_wpgmp_location_city%":"Kershaw","%_wpgmp_location_state%":"SC","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Kershaw, SC, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"34.5518201","%_wpgmp_metabox_longitude%":"-80.5836836","%rank_math_internal_links_processed%":"1"}},"id":2217,"infowindow_disable":false},{"source":"post","title":"Haul Truck Operator &#8211; Mining","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Haul Truck Operator &#8211; Mining\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Job Title:&nbsp;Haul Truck Driver Company:&nbsp;Mining Company (Partnered with Turner Staffing Group) Location:&nbsp;Kershaw, SC Position Type:&nbsp;Full-Time About Us:&nbsp;Turner Staffing Group is&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/haul-truck-operator-mining\/\" name=\"Haul Truck Operator &#8211; Mining\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Job Title:&nbsp;Haul Truck Driver Company:&nbsp;Mining Company (Partnered with Turner Staffing Group) Location:&nbsp;Kershaw, SC Position Type:&nbsp;Full-Time About Us:&nbsp;Turner Staffing Group is&hellip;","address":"Kershaw, SC, USA","location":{"lat":"34.5518201","city":"Kershaw","state":"SC","country":"United States","lng":"-80.5836836","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/haul-truck-operator-mining\/","zoom":19,"extra_fields":{"post_excerpt":"Job Title:&nbsp;Haul Truck Driver Company:&nbsp;Mining Company (Partnered with Turner Staffing Group) Location:&nbsp;Kershaw, SC Position Type:&nbsp;Full-Time About Us:&nbsp;Turner Staffing Group is&hellip;","post_content":"<p><strong>Job Title:<\/strong>&nbsp;Haul Truck Driver<\/p>\n<p><strong>Company:&nbsp;<\/strong>Mining Company (Partnered with Turner Staffing Group)<\/p>\n<p><strong>Location:<\/strong>&nbsp;Kershaw, SC<\/p>\n<p><strong>Position Type:<\/strong>&nbsp;Full-Time<\/p>\n<p><strong>About Us:<\/strong>&nbsp;Turner Staffing Group is proud to partner with a leading Mining Company in Kershaw, SC, dedicated to responsible and sustainable mining practices. Together, we are seeking a skilled and safety-conscious Haul Truck Driver to join the mining operations team. This is an exciting opportunity to contribute to the success of a well-established mining company committed to excellence and environmental stewardship.<\/p>\n<p><strong>Job Overview:<\/strong>&nbsp;As a Haul Truck Driver, you will play a crucial role in the transportation of materials within the mining site, ensuring the safe and efficient movement of material. The ideal candidate will have experience operating large haul trucks, a strong commitment to safety, and the ability to work in a dynamic mining environment.<\/p>\n<p><strong>Responsibilities:<\/strong><\/p>\n<ol><li><strong>Safe Operation of Haul Trucks:<\/strong><ul><li>Operate haul trucks to transport materials within the mining site.<\/li><li>Adhere to all safety protocols and guidelines to ensure a safe working environment.<\/li><\/ul><\/li><li><strong>Material Transportation:<\/strong><ul><li>Load, transport, and unload materials according to project specifications and production schedules.<\/li><li>Communicate effectively with equipment operators and supervisors to coordinate material movement.<\/li><\/ul><\/li><li><strong>Equipment Maintenance:<\/strong><ul><li>Conduct pre-shift inspections on haul trucks and report any issues to the maintenance team.<\/li><li>Ensure routine maintenance tasks are performed to keep equipment in optimal condition.<\/li><\/ul><\/li><li><strong>Safety Compliance:<\/strong><ul><li>Follow safety procedures and guidelines to prevent accidents and injuries.<\/li><li>Participate in safety meetings and training sessions as required.<\/li><\/ul><\/li><li><strong>Record Keeping:<\/strong><ul><li>Maintain accurate records of material transported, distances covered, and fuel consumption.<\/li><li>Report any incidents or accidents promptly.<\/li><\/ul><\/li><\/ol>\n<p><strong>Requirements:<\/strong><\/p>\n<ul><li>Proven experience as a Articulating Haul Truck Driver in a mining or heavy equipment environment.<\/li><li>MSHA certificate preferred.&nbsp;<\/li><li>Knowledge of safe haul truck operation practices.<\/li><li>Ability to work in a physically demanding and outdoor environment.<\/li><li>Strong communication skills and the ability to work as part of a team.<\/li><\/ul>\n<p><strong>Benefits:<\/strong><\/p>\n<ul><li>Competitive salary<\/li><li>Health, dental, and vision insurance<\/li><li>Retirement savings plan<\/li><\/ul>","post_title":"Haul Truck Operator &#8211; Mining","post_link":"https:\/\/turnerstaffing.com\/position\/haul-truck-operator-mining\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Associate","%location_country%":"United States","%location_city%":"Kershaw","%location_state_id%":"SC","%location_state_name%":"South Carolina","%location_city_state%":"Kershaw, SC","%education%":"Unspecified","%department%":"Operations","%description%":"<p><strong>Job Title:<\/strong>&nbsp;Haul Truck Driver<\/p>\n<p><strong>Company:&nbsp;<\/strong>Mining Company (Partnered with Turner Staffing Group)<\/p>\n<p><strong>Location:<\/strong>&nbsp;Kershaw, SC<\/p>\n<p><strong>Position Type:<\/strong>&nbsp;Full-Time<\/p>\n<p><strong>About Us:<\/strong>&nbsp;Turner Staffing Group is proud to partner with a leading Mining Company in Kershaw, SC, dedicated to responsible and sustainable mining practices. Together, we are seeking a skilled and safety-conscious Haul Truck Driver to join the mining operations team. This is an exciting opportunity to contribute to the success of a well-established mining company committed to excellence and environmental stewardship.<\/p>\n<p><strong>Job Overview:<\/strong>&nbsp;As a Haul Truck Driver, you will play a crucial role in the transportation of materials within the mining site, ensuring the safe and efficient movement of material. The ideal candidate will have experience operating large haul trucks, a strong commitment to safety, and the ability to work in a dynamic mining environment.<\/p>\n<p><strong>Responsibilities:<\/strong><\/p>\n<ol><li><strong>Safe Operation of Haul Trucks:<\/strong><ul><li>Operate haul trucks to transport materials within the mining site.<\/li><li>Adhere to all safety protocols and guidelines to ensure a safe working environment.<\/li><\/ul><\/li><li><strong>Material Transportation:<\/strong><ul><li>Load, transport, and unload materials according to project specifications and production schedules.<\/li><li>Communicate effectively with equipment operators and supervisors to coordinate material movement.<\/li><\/ul><\/li><li><strong>Equipment Maintenance:<\/strong><ul><li>Conduct pre-shift inspections on haul trucks and report any issues to the maintenance team.<\/li><li>Ensure routine maintenance tasks are performed to keep equipment in optimal condition.<\/li><\/ul><\/li><li><strong>Safety Compliance:<\/strong><ul><li>Follow safety procedures and guidelines to prevent accidents and injuries.<\/li><li>Participate in safety meetings and training sessions as required.<\/li><\/ul><\/li><li><strong>Record Keeping:<\/strong><ul><li>Maintain accurate records of material transported, distances covered, and fuel consumption.<\/li><li>Report any incidents or accidents promptly.<\/li><\/ul><\/li><\/ol>\n<p><strong>Requirements:<\/strong><\/p>\n<ul><li>Proven experience as a Articulating Haul Truck Driver in a mining or heavy equipment environment.<\/li><li>MSHA certificate preferred.&nbsp;<\/li><li>Knowledge of safe haul truck operation practices.<\/li><li>Ability to work in a physically demanding and outdoor environment.<\/li><li>Strong communication skills and the ability to work as part of a team.<\/li><\/ul>\n<p><strong>Benefits:<\/strong><\/p>\n<ul><li>Competitive salary<\/li><li>Health, dental, and vision insurance<\/li><li>Retirement savings plan<\/li><\/ul>","%category%":"Other","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/006a47caa139-haul-truck-operator-mining","%breezy_id%":"006a47caa139","%breezy_friendly_id%":"006a47caa139-haul-truck-operator-mining","%breezy_created_date%":"2024-02-28T15:08:18.371Z","%breezy_updated_date%":"2025-03-05T14:22:16.789Z","%_wpgmp_location_city%":"Kershaw","%_wpgmp_location_state%":"SC","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Kershaw, SC, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"34.5518201","%_wpgmp_metabox_longitude%":"-80.5836836","%rank_math_internal_links_processed%":"1"}},"id":2216,"infowindow_disable":false},{"source":"post","title":"Contracts Specialist","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Contracts Specialist\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Turner Staffing Group is currently seeking a Contracts Specialist to join our team to work at our client&#8217;s office near&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/contracts-specialist-2\/\" name=\"Contracts Specialist\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Turner Staffing Group is currently seeking a Contracts Specialist to join our team to work at our client&#8217;s office near&hellip;","address":"Elko, NV, USA","location":{"lat":"40.8436459","city":"Elko","state":"NV","country":"United States","lng":"-115.7526187","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/contracts-specialist-2\/","zoom":19,"extra_fields":{"post_excerpt":"Turner Staffing Group is currently seeking a Contracts Specialist to join our team to work at our client&#8217;s office near&hellip;","post_content":"<p>Turner Staffing Group is currently seeking a Contracts Specialist to join our team to work at our client's office near Elko, NV. This onsite, project-based position will support the tendering and awarding of contracts for goods and services related to near-mine or in-mine facilities, adhering to established policies and procedures. This role will involve working as part of a team, with indirect supervision, and performing a wide range of contract acquisition and administration tasks.<\/p><p><strong>Key Responsibilities:<\/strong><\/p><ul><li>Responsible for delivering contracts that meet the operational and commercial needs of user areas, ensuring the timely supply of goods and services.<\/li><li>Manage the tender process, including developing contract documentation, coordinating information for evaluating proposals, and supporting the selection of service providers.<\/li><li>Prepare letters, reports, and other documents to support contractual actions or recommendations.<\/li><li>Maintain and update a contracts register for the end-user group.<\/li><li>Support the continuous improvement of sourcing strategies, policies, and guidelines related to service categories and contracts.<\/li><li>Ensure professional service to user departments, including bid preparation, negotiations with suppliers, and management of contract execution and closeouts.<\/li><li>Analyze solicitation responses, including price reasonableness, competition, compliance, and requirements fulfillment.<\/li><li>Act as a central point of contact for assigned procurements and manage contractor\/vendor relationships.<\/li><li>Monitor contractor compliance with contractual obligations, including cost and schedule management.<\/li><li>Acquire services that meet operational requirements while optimizing cost, execution time, and quality.<\/li><li>Support program integration and the implementation of best practices in project controls and governance.<\/li><li>Resolve queries from operations, providing information on policies and work products, and referring to others for policy interpretation when necessary.<\/li><li>Utilize sourcing and procurement systems approved for contract execution and management.<\/li><li>Handle small project workstreams, ensuring adherence to project management methodologies and permitting processes.<\/li><li>Follow HS&amp;E policies and procedures to mitigate environmental and workplace risks.<\/li><li>Continue professional development by participating in training and gaining relevant accreditation.<\/li><li>Be available for after-hour emergency procurement activities during scheduled \"on-call\" rotations.<\/li><\/ul><p><strong>Qualifications:<\/strong><\/p><p><strong>Education:<\/strong><\/p><ul><li>Bachelor&rsquo;s degree in Business, Supply Chain, Accounting, or a related field, or equivalent experience.<\/li><\/ul><p><strong>Experience:<\/strong><\/p><ul><li>Minimum of 5 years of directly related contracting and procurement experience or an equivalent combination of training and experience.<\/li><li>Experience in developing RFQs and RFPs.<\/li><li>Expertise in negotiating contractual conflict resolution.<\/li><li>Proficiency with Ariba or similar sourcing and contract management systems.<\/li><li>Strong skills in Microsoft Office Suite (Word, Excel, PowerPoint, Visio, Outlook).<\/li><li>Authorized to work in the US without work visa sponsorship.<\/li><li>Local candidates only<\/li><\/ul>","post_title":"Contracts Specialist","post_link":"https:\/\/turnerstaffing.com\/position\/contracts-specialist-2\/","post_featured_image":"","post_categories":"","post_tags":"","%location_country%":"United States","%location_city%":"Elko","%location_state_id%":"NV","%location_city_state%":"Elko, NV","%description%":"<p>Turner Staffing Group is currently seeking a Contracts Specialist to join our team to work at our client's office near Elko, NV. This onsite, project-based position will support the tendering and awarding of contracts for goods and services related to near-mine or in-mine facilities, adhering to established policies and procedures. This role will involve working as part of a team, with indirect supervision, and performing a wide range of contract acquisition and administration tasks.<\/p><p><strong>Key Responsibilities:<\/strong><\/p><ul><li>Responsible for delivering contracts that meet the operational and commercial needs of user areas, ensuring the timely supply of goods and services.<\/li><li>Manage the tender process, including developing contract documentation, coordinating information for evaluating proposals, and supporting the selection of service providers.<\/li><li>Prepare letters, reports, and other documents to support contractual actions or recommendations.<\/li><li>Maintain and update a contracts register for the end-user group.<\/li><li>Support the continuous improvement of sourcing strategies, policies, and guidelines related to service categories and contracts.<\/li><li>Ensure professional service to user departments, including bid preparation, negotiations with suppliers, and management of contract execution and closeouts.<\/li><li>Analyze solicitation responses, including price reasonableness, competition, compliance, and requirements fulfillment.<\/li><li>Act as a central point of contact for assigned procurements and manage contractor\/vendor relationships.<\/li><li>Monitor contractor compliance with contractual obligations, including cost and schedule management.<\/li><li>Acquire services that meet operational requirements while optimizing cost, execution time, and quality.<\/li><li>Support program integration and the implementation of best practices in project controls and governance.<\/li><li>Resolve queries from operations, providing information on policies and work products, and referring to others for policy interpretation when necessary.<\/li><li>Utilize sourcing and procurement systems approved for contract execution and management.<\/li><li>Handle small project workstreams, ensuring adherence to project management methodologies and permitting processes.<\/li><li>Follow HS&amp;E policies and procedures to mitigate environmental and workplace risks.<\/li><li>Continue professional development by participating in training and gaining relevant accreditation.<\/li><li>Be available for after-hour emergency procurement activities during scheduled \"on-call\" rotations.<\/li><\/ul><p><strong>Qualifications:<\/strong><\/p><p><strong>Education:<\/strong><\/p><ul><li>Bachelor&rsquo;s degree in Business, Supply Chain, Accounting, or a related field, or equivalent experience.<\/li><\/ul><p><strong>Experience:<\/strong><\/p><ul><li>Minimum of 5 years of directly related contracting and procurement experience or an equivalent combination of training and experience.<\/li><li>Experience in developing RFQs and RFPs.<\/li><li>Expertise in negotiating contractual conflict resolution.<\/li><li>Proficiency with Ariba or similar sourcing and contract management systems.<\/li><li>Strong skills in Microsoft Office Suite (Word, Excel, PowerPoint, Visio, Outlook).<\/li><li>Authorized to work in the US without work visa sponsorship.<\/li><li>Local candidates only<\/li><\/ul>","%application_url%":"https:\/\/jobs.crelate.com\/portal\/turnerstaffinggroup\/job\/sto6idncdr7yscti9kaz7equ5a","%crelate_id%":"sto6idncdr7yscti9kaz7equ5a","%crelate_created_date%":"2025-03-03T20:22:49.45Z","%crelate_updated_date%":"2025-03-27T13:35:36.04Z","%_wpgmp_location_city%":"Elko","%_wpgmp_location_state%":"NV","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Elko, NV, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"40.8436459","%_wpgmp_metabox_longitude%":"-115.7526187","%rank_math_internal_links_processed%":"1"}},"id":2215,"infowindow_disable":false},{"source":"post","title":"Contracts Specialist","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Contracts Specialist\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Turner Staffing Group is currently seeking a Contracts Specialist to join our team to work at our client&#8217;s office near&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/contracts-specialist\/\" name=\"Contracts Specialist\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Turner Staffing Group is currently seeking a Contracts Specialist to join our team to work at our client&#8217;s office near&hellip;","address":"Elko, NV, USA","location":{"lat":"40.8436459","city":"Elko","state":"NV","country":"United States","lng":"-115.7526187","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/contracts-specialist\/","zoom":19,"extra_fields":{"post_excerpt":"Turner Staffing Group is currently seeking a Contracts Specialist to join our team to work at our client&#8217;s office near&hellip;","post_content":"<p>Turner Staffing Group is currently seeking a Contracts Specialist to join our team to work at our client's office near Elko, NV. This onsite, project-based position will support the tendering and awarding of contracts for goods and services related to near-mine or in-mine facilities, adhering to established policies and procedures. This role will involve working as part of a team, with indirect supervision, and performing a wide range of contract acquisition and administration tasks.<\/p>\n<p><strong>Key Responsibilities:<\/strong><\/p>\n<ul><li>Responsible for delivering contracts that meet the operational and commercial needs of user areas, ensuring the timely supply of goods and services.<\/li><li>Manage the tender process, including developing contract documentation, coordinating information for evaluating proposals, and supporting the selection of service providers.<\/li><li>Prepare letters, reports, and other documents to support contractual actions or recommendations.<\/li><li>Maintain and update a contracts register for the end-user group.<\/li><li>Support the continuous improvement of sourcing strategies, policies, and guidelines related to service categories and contracts.<\/li><li>Ensure professional service to user departments, including bid preparation, negotiations with suppliers, and management of contract execution and closeouts.<\/li><li>Analyze solicitation responses, including price reasonableness, competition, compliance, and requirements fulfillment.<\/li><li>Act as a central point of contact for assigned procurements and manage contractor\/vendor relationships.<\/li><li>Monitor contractor compliance with contractual obligations, including cost and schedule management.<\/li><li>Acquire services that meet operational requirements while optimizing cost, execution time, and quality.<\/li><li>Support program integration and the implementation of best practices in project controls and governance.<\/li><li>Resolve queries from operations, providing information on policies and work products, and referring to others for policy interpretation when necessary.<\/li><li>Utilize sourcing and procurement systems approved for contract execution and management.<\/li><li>Handle small project workstreams, ensuring adherence to project management methodologies and permitting processes.<\/li><li>Follow HS&amp;E policies and procedures to mitigate environmental and workplace risks.<\/li><li>Continue professional development by participating in training and gaining relevant accreditation.<\/li><li>Be available for after-hour emergency procurement activities during scheduled \"on-call\" rotations.<\/li><\/ul>\n<p><strong>Qualifications:<\/strong><\/p>\n<p><strong>Education:<\/strong><\/p>\n<ul><li>Bachelor\u2019s degree in Business, Supply Chain, Accounting, or a related field, or equivalent experience.<\/li><\/ul>\n<p><strong>Experience:<\/strong><\/p>\n<ul><li>Minimum of 5 years of directly related contracting and procurement experience or an equivalent combination of training and experience.<\/li><li>Experience in developing RFQs and RFPs.<\/li><li>Expertise in negotiating contractual conflict resolution.<\/li><li>Proficiency with Ariba or similar sourcing and contract management systems.<\/li><li>Strong skills in Microsoft Office Suite (Word, Excel, PowerPoint, Visio, Outlook).<\/li><li>Authorized to work in the US without work visa sponsorship.<\/li><li>Local candidates only<\/li><\/ul>","post_title":"Contracts Specialist","post_link":"https:\/\/turnerstaffing.com\/position\/contracts-specialist\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"","%location_country%":"United States","%location_city%":"Elko","%location_state_id%":"NV","%location_state_name%":"Nevada","%location_city_state%":"Elko, NV","%education%":"","%department%":"","%description%":"<p>Turner Staffing Group is currently seeking a Contracts Specialist to join our team to work at our client's office near Elko, NV. This onsite, project-based position will support the tendering and awarding of contracts for goods and services related to near-mine or in-mine facilities, adhering to established policies and procedures. This role will involve working as part of a team, with indirect supervision, and performing a wide range of contract acquisition and administration tasks.<\/p>\n<p><strong>Key Responsibilities:<\/strong><\/p>\n<ul><li>Responsible for delivering contracts that meet the operational and commercial needs of user areas, ensuring the timely supply of goods and services.<\/li><li>Manage the tender process, including developing contract documentation, coordinating information for evaluating proposals, and supporting the selection of service providers.<\/li><li>Prepare letters, reports, and other documents to support contractual actions or recommendations.<\/li><li>Maintain and update a contracts register for the end-user group.<\/li><li>Support the continuous improvement of sourcing strategies, policies, and guidelines related to service categories and contracts.<\/li><li>Ensure professional service to user departments, including bid preparation, negotiations with suppliers, and management of contract execution and closeouts.<\/li><li>Analyze solicitation responses, including price reasonableness, competition, compliance, and requirements fulfillment.<\/li><li>Act as a central point of contact for assigned procurements and manage contractor\/vendor relationships.<\/li><li>Monitor contractor compliance with contractual obligations, including cost and schedule management.<\/li><li>Acquire services that meet operational requirements while optimizing cost, execution time, and quality.<\/li><li>Support program integration and the implementation of best practices in project controls and governance.<\/li><li>Resolve queries from operations, providing information on policies and work products, and referring to others for policy interpretation when necessary.<\/li><li>Utilize sourcing and procurement systems approved for contract execution and management.<\/li><li>Handle small project workstreams, ensuring adherence to project management methodologies and permitting processes.<\/li><li>Follow HS&amp;E policies and procedures to mitigate environmental and workplace risks.<\/li><li>Continue professional development by participating in training and gaining relevant accreditation.<\/li><li>Be available for after-hour emergency procurement activities during scheduled \"on-call\" rotations.<\/li><\/ul>\n<p><strong>Qualifications:<\/strong><\/p>\n<p><strong>Education:<\/strong><\/p>\n<ul><li>Bachelor\u2019s degree in Business, Supply Chain, Accounting, or a related field, or equivalent experience.<\/li><\/ul>\n<p><strong>Experience:<\/strong><\/p>\n<ul><li>Minimum of 5 years of directly related contracting and procurement experience or an equivalent combination of training and experience.<\/li><li>Experience in developing RFQs and RFPs.<\/li><li>Expertise in negotiating contractual conflict resolution.<\/li><li>Proficiency with Ariba or similar sourcing and contract management systems.<\/li><li>Strong skills in Microsoft Office Suite (Word, Excel, PowerPoint, Visio, Outlook).<\/li><li>Authorized to work in the US without work visa sponsorship.<\/li><li>Local candidates only<\/li><\/ul>","%category%":"","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/eee9838e221b-contracts-specialist","%breezy_id%":"eee9838e221b","%breezy_friendly_id%":"eee9838e221b-contracts-specialist","%breezy_created_date%":"2025-03-04T02:46:45.802Z","%breezy_updated_date%":"2025-03-04T02:47:10.790Z","%_wpgmp_location_city%":"Elko","%_wpgmp_location_state%":"NV","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Elko, NV, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"40.8436459","%_wpgmp_metabox_longitude%":"-115.7526187","%rank_math_internal_links_processed%":"1"}},"id":2213,"infowindow_disable":false},{"source":"post","title":"Utility Operator (Excavator Operator)","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Utility Operator (Excavator Operator)\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    We are actively seeking a Lead Excavator Operator with pipeline experience to work with us in the Charlotte, NC area.&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/utility-operator-excavator-operator\/\" name=\"Utility Operator (Excavator Operator)\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"We are actively seeking a Lead Excavator Operator with pipeline experience to work with us in the Charlotte, NC area.&hellip;","address":"Charlotte, NC, USA","location":{"lat":"35.2215548","city":"Charlotte","state":"NC","country":"United States","lng":"-80.840116","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/utility-operator-excavator-operator\/","zoom":19,"extra_fields":{"post_excerpt":"We are actively seeking a Lead Excavator Operator with pipeline experience to work with us in the Charlotte, NC area.&hellip;","post_content":"<p>We are actively seeking a Lead Excavator Operator with pipeline experience to work with us in the Charlotte, NC area. This position will work under the direction of a foreman or superintendent and collaborate with a team of construction professionals to ensure successful utility installation projects.<\/p>\n<p><strong>Essential Duties &amp; Responsibilities:<\/strong><\/p>\n<ul><li>Communicate professionally with supervisors, teammates, contractors, clients, and vendors.<\/li><li>Understand, interpret, and follow goals and directions from foreman or superintendent.<\/li><li>Maintain cleanliness of all equipment.<\/li><li>Attend work regularly during assigned work hours or any other schedule as required.<\/li><li>Willingness to work overtime or on Saturdays as needed.<\/li><li>Participate in necessary training sessions.<\/li><\/ul>\n<p><strong>Other Duties &amp; Responsibilities:<\/strong><\/p>\n<ul><li>Assist with other tasks as needed, including supporting other roles on the crew.<\/li><\/ul>\n<p><strong>Experience &amp; Requirements:<\/strong><\/p>\n<ul><li>At least two years of experience operating excavators for pipeline work, including digging inside trench boxes and setting heavy loads such as precast structures and pipe.<\/li><li>Familiarity with OSHA Trenching and Shoring requirements.<\/li><li>Ability to read and understand grade stakes.<\/li><li>Must be able to work Monday through Friday, 7 AM \u2013 5:30 PM, and Saturdays when needed.<\/li><li>Strong communication skills and the ability to work effectively with supervisors and teammates.<\/li><li>Reliable transportation.<\/li><li>Ability to pass a pre-employment drug test and background screening.<\/li><li>Must be 18 years of age or older.<\/li><\/ul>\n<p><strong>Physical Demands:<\/strong><\/p>\n<ul><li>Able to stand\/sit for extended periods, as well as stoop, kneel, walk, bend, crouch, lift, and crawl.<\/li><li>Able to climb on and off equipment safely.<\/li><li>Able to lift 40-80 lbs regularly.<\/li><li>Comfortable working outdoors in varying weather conditions.<\/li><li>Able to use hands, arms, and feet for repetitive lifting and carrying of materials.<\/li><\/ul>\n<p><strong>Company Benefits:<\/strong><\/p>\n<ul><li>Competitive pay (based on experience)<\/li><li>Medical insurance<\/li><li>Short-term disability<\/li><li>Group term life insurance<\/li><li>Voluntary dental, vision, and life insurance<\/li><li>Voluntary long-term disability<\/li><li>401(k) plan with company match<\/li><li>Paid vacation, holidays, and leave<\/li><li>Profit-sharing program<\/li><li>Free training programs<\/li><\/ul>","post_title":"Utility Operator (Excavator Operator)","post_link":"https:\/\/turnerstaffing.com\/position\/utility-operator-excavator-operator\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"","%location_country%":"United States","%location_city%":"Charlotte","%location_state_id%":"NC","%location_state_name%":"North Carolina","%location_city_state%":"Charlotte, NC","%education%":"","%department%":"","%description%":"<p>We are actively seeking a Lead Excavator Operator with pipeline experience to work with us in the Charlotte, NC area. This position will work under the direction of a foreman or superintendent and collaborate with a team of construction professionals to ensure successful utility installation projects.<\/p>\n<p><strong>Essential Duties &amp; Responsibilities:<\/strong><\/p>\n<ul><li>Communicate professionally with supervisors, teammates, contractors, clients, and vendors.<\/li><li>Understand, interpret, and follow goals and directions from foreman or superintendent.<\/li><li>Maintain cleanliness of all equipment.<\/li><li>Attend work regularly during assigned work hours or any other schedule as required.<\/li><li>Willingness to work overtime or on Saturdays as needed.<\/li><li>Participate in necessary training sessions.<\/li><\/ul>\n<p><strong>Other Duties &amp; Responsibilities:<\/strong><\/p>\n<ul><li>Assist with other tasks as needed, including supporting other roles on the crew.<\/li><\/ul>\n<p><strong>Experience &amp; Requirements:<\/strong><\/p>\n<ul><li>At least two years of experience operating excavators for pipeline work, including digging inside trench boxes and setting heavy loads such as precast structures and pipe.<\/li><li>Familiarity with OSHA Trenching and Shoring requirements.<\/li><li>Ability to read and understand grade stakes.<\/li><li>Must be able to work Monday through Friday, 7 AM \u2013 5:30 PM, and Saturdays when needed.<\/li><li>Strong communication skills and the ability to work effectively with supervisors and teammates.<\/li><li>Reliable transportation.<\/li><li>Ability to pass a pre-employment drug test and background screening.<\/li><li>Must be 18 years of age or older.<\/li><\/ul>\n<p><strong>Physical Demands:<\/strong><\/p>\n<ul><li>Able to stand\/sit for extended periods, as well as stoop, kneel, walk, bend, crouch, lift, and crawl.<\/li><li>Able to climb on and off equipment safely.<\/li><li>Able to lift 40-80 lbs regularly.<\/li><li>Comfortable working outdoors in varying weather conditions.<\/li><li>Able to use hands, arms, and feet for repetitive lifting and carrying of materials.<\/li><\/ul>\n<p><strong>Company Benefits:<\/strong><\/p>\n<ul><li>Competitive pay (based on experience)<\/li><li>Medical insurance<\/li><li>Short-term disability<\/li><li>Group term life insurance<\/li><li>Voluntary dental, vision, and life insurance<\/li><li>Voluntary long-term disability<\/li><li>401(k) plan with company match<\/li><li>Paid vacation, holidays, and leave<\/li><li>Profit-sharing program<\/li><li>Free training programs<\/li><\/ul>","%category%":"","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/1c988197c1ae-utility-operator-excavator-operator","%breezy_id%":"1c988197c1ae","%breezy_friendly_id%":"1c988197c1ae-utility-operator-excavator-operator","%breezy_created_date%":"2025-03-04T18:11:14.690Z","%breezy_updated_date%":"2025-03-04T18:13:04.465Z","%_wpgmp_location_city%":"Charlotte","%_wpgmp_location_state%":"NC","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Charlotte, NC, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"35.2215548","%_wpgmp_metabox_longitude%":"-80.840116","%rank_math_internal_links_processed%":"1"}},"id":2214,"infowindow_disable":false},{"source":"post","title":"Project Superintendent- Utilities","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Project Superintendent- Utilities\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    The Project Superintendent is responsible for overseeing the on-site execution of projects, managing day-to-day construction activities, ensuring quality control, and&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/project-superintendent-utilities\/\" name=\"Project Superintendent- Utilities\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"The Project Superintendent is responsible for overseeing the on-site execution of projects, managing day-to-day construction activities, ensuring quality control, and&hellip;","address":"Harmony, MN, USA","location":{"lat":"43.5551811","city":"Harmony","state":"MN","country":"United States","lng":"-92.0052837","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/project-superintendent-utilities\/","zoom":19,"extra_fields":{"post_excerpt":"The Project Superintendent is responsible for overseeing the on-site execution of projects, managing day-to-day construction activities, ensuring quality control, and&hellip;","post_content":"<p>The Project Superintendent is responsible for overseeing the on-site execution of projects, managing day-to-day construction activities, ensuring quality control, and maintaining strong coordination between the field team, Project Administrator, and Project Manager. The Superintendent ensures projects are completed safely, on-time, and within budget while upholding the company\u2019s mission to transform lives.<\/p>\n<p>WHAT SKILLS DO I NEED TO DO THIS JOB EXTRAORDINARILY WELL?<\/p>\n<p>Skills required:<\/p>\n<p>- 5-7 years experience in coordinating and leading plow and drill crews in construction.<\/p>\n<p>- The ability to lead crews with safety as the top priority, including leading the morning meeting with a clear path forward<\/p>\n<p>- Strong organizational skills and a keen eye for detail.<\/p>\n<p>- Excellent communication and professional skills.<\/p>\n<p>- A \u201cI will attack this problem\u201d mindset.<\/p>\n<p>- Understanding of underground cable systems- ie. fiber networks, utility grids, and construction processes.<\/p>\n<p>- Must be able to create and maintain day-to-day processes involving production reporting, ensuring schedules and budget, and maintaining equipment.<\/p>\n<p>- Work closely with the Project Manager to ensure proper staffing.<\/p>\n<p>- Must be a self-starter, bring a positive attitude to the team, have a desire to succeed and make a difference in your team and community!<\/p>\n<p>Key Relationships:<\/p>\n<p>- Reports to: Project Manager<\/p>\n<p>- Works closely with: Project Manager, Project Administrator, and Field Foreman.<\/p>\n<p>- Direct Reports: Field Crews (laborers, operators, etc).<\/p>","post_title":"Project Superintendent- Utilities","post_link":"https:\/\/turnerstaffing.com\/position\/project-superintendent-utilities\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Senior","%location_country%":"United States","%location_city%":"Harmony","%location_state_id%":"MN","%location_state_name%":"Minnesota","%location_city_state%":"Harmony, MN","%education%":"Unspecified","%department%":"","%description%":"<p>The Project Superintendent is responsible for overseeing the on-site execution of projects, managing day-to-day construction activities, ensuring quality control, and maintaining strong coordination between the field team, Project Administrator, and Project Manager. The Superintendent ensures projects are completed safely, on-time, and within budget while upholding the company\u2019s mission to transform lives.<\/p>\n<p>WHAT SKILLS DO I NEED TO DO THIS JOB EXTRAORDINARILY WELL?<\/p>\n<p>Skills required:<\/p>\n<p>- 5-7 years experience in coordinating and leading plow and drill crews in construction.<\/p>\n<p>- The ability to lead crews with safety as the top priority, including leading the morning meeting with a clear path forward<\/p>\n<p>- Strong organizational skills and a keen eye for detail.<\/p>\n<p>- Excellent communication and professional skills.<\/p>\n<p>- A \u201cI will attack this problem\u201d mindset.<\/p>\n<p>- Understanding of underground cable systems- ie. fiber networks, utility grids, and construction processes.<\/p>\n<p>- Must be able to create and maintain day-to-day processes involving production reporting, ensuring schedules and budget, and maintaining equipment.<\/p>\n<p>- Work closely with the Project Manager to ensure proper staffing.<\/p>\n<p>- Must be a self-starter, bring a positive attitude to the team, have a desire to succeed and make a difference in your team and community!<\/p>\n<p>Key Relationships:<\/p>\n<p>- Reports to: Project Manager<\/p>\n<p>- Works closely with: Project Manager, Project Administrator, and Field Foreman.<\/p>\n<p>- Direct Reports: Field Crews (laborers, operators, etc).<\/p>","%category%":"Management","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/2d4cfb2043b4-project-superintendent-utilities","%breezy_id%":"2d4cfb2043b4","%breezy_friendly_id%":"2d4cfb2043b4-project-superintendent-utilities","%breezy_created_date%":"2025-03-03T16:31:15.112Z","%breezy_updated_date%":"2025-03-03T16:31:47.054Z","%_wpgmp_location_city%":"Harmony","%_wpgmp_location_state%":"MN","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Harmony, MN, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"43.5551811","%_wpgmp_metabox_longitude%":"-92.0052837","%rank_math_internal_links_processed%":"1"}},"id":2211,"infowindow_disable":false},{"source":"post","title":"CAT D6 Dozer Operator","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    CAT D6 Dozer Operator\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Job Summary: We are seeking a skilled and experienced CAT D6 Dozer Operator for a 5-month contract position based in&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/cat-d6-dozer-operator\/\" name=\"CAT D6 Dozer Operator\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Job Summary: We are seeking a skilled and experienced CAT D6 Dozer Operator for a 5-month contract position based in&hellip;","address":"Wells, NV, USA","location":{"lat":"41.1115888","city":"Wells","state":"NV","country":"United States","lng":"-114.96449","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/cat-d6-dozer-operator\/","zoom":19,"extra_fields":{"post_excerpt":"Job Summary: We are seeking a skilled and experienced CAT D6 Dozer Operator for a 5-month contract position based in&hellip;","post_content":"<p>Job Summary:<\/p>\n\n<p>We are seeking a skilled and experienced CAT D6 Dozer Operator for a 5-month contract position based in Wells, Nevada. The ideal candidate will have at least 5 years of experience operating CAT D6 Dozers, with a strong focus on safety, efficiency, and quality. This position requires a dedicated professional to perform a variety of tasks related to construction, earthmoving, and site preparation on a project site.<\/p>\n<p><br><\/p>\n<p>Key Responsibilities:<\/p>\n<p>- Operate a CAT D6 Dozer for a variety of tasks including grading, leveling, clearing, and trenching on construction sites.<\/p>\n<p>- Perform pre-operation inspections and basic maintenance on the CAT D6 Dozer to ensure safe and efficient operation.<\/p>\n<p>- Follow project specifications and plans to ensure proper execution of work according to safety standards.<\/p>\n<p>- Work collaboratively with other equipment operators, laborers, and supervisors to meet project goals and deadlines.<\/p>\n<p>- Adhere to safety protocols and contribute to maintaining a safe work environment.<\/p>\n<p>- Communicate effectively with the team to coordinate tasks and report any issues or delays.<\/p>\n<p>- Complete necessary documentation and reports related to equipment use, work hours, and materials.<\/p>\n<p>---<\/p>\n<p>Required Qualifications:<\/p>\n<p>- Minimum 5 years of experience operating a CAT D6 Dozer or similar equipment in construction or heavy equipment operations.<\/p>\n<p>- Proven ability to perform tasks such as grading, clearing, and leveling with a high degree of precision.<\/p>\n<p>- Strong knowledge of equipment safety procedures and standard operating practices.<\/p>\n<p>- Ability to read and interpret project plans, blueprints, and specifications.<\/p>\n<p>- Valid driver\u2019s license and clean driving record.<\/p>\n<p>- Ability to perform basic machine maintenance, including lubricating and servicing equipment.<\/p>\n<p>- Must pass a pre-employment drug screening and background check.<\/p><p><br><\/p>\n\n<p>Preferred Qualifications:<\/p>\n<p>- Experience working in remote locations or with short-term contract positions.<\/p>\n<p>- Knowledge of additional heavy equipment operations.<\/p><p><br><\/p>\n\n<p>Physical Requirements:<\/p>\n<p>- Ability to lift up to 50 lbs regularly.<\/p>\n<p>- Ability to stand, walk, bend, or sit for extended periods.<\/p>\n<p>- Comfortable working in varying weather conditions (heat, cold, dust).<\/p>\n<p><br><\/p>\n<p>Compensation and Benefits:<\/p>\n<p>- Competitive hourly rate based on experience.<\/p>\n<p>- Potential for overtime based on project needs.<\/p>\n<p>- Accommodation assistance and travel arrangements if applicable.<\/p>\n<p>- Opportunity to gain experience with a reputable construction project in Nevada.<\/p>\n<p><br><\/p>\n<p>If you meet the qualifications and are interested in contributing to a dynamic team for a short-term contract position, please apply with your resume and relevant certifications. <\/p>\n<p>We look forward to hearing from you!<\/p>","post_title":"CAT D6 Dozer Operator","post_link":"https:\/\/turnerstaffing.com\/position\/cat-d6-dozer-operator\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Contract","%experience%":"Mid Level","%location_country%":"United States","%location_city%":"Wells","%location_state_id%":"NV","%location_state_name%":"Nevada","%location_city_state%":"Wells, NV","%education%":"Unspecified","%department%":"","%description%":"<p>Job Summary:<\/p>\n\n<p>We are seeking a skilled and experienced CAT D6 Dozer Operator for a 5-month contract position based in Wells, Nevada. The ideal candidate will have at least 5 years of experience operating CAT D6 Dozers, with a strong focus on safety, efficiency, and quality. This position requires a dedicated professional to perform a variety of tasks related to construction, earthmoving, and site preparation on a project site.<\/p>\n<p><br><\/p>\n<p>Key Responsibilities:<\/p>\n<p>- Operate a CAT D6 Dozer for a variety of tasks including grading, leveling, clearing, and trenching on construction sites.<\/p>\n<p>- Perform pre-operation inspections and basic maintenance on the CAT D6 Dozer to ensure safe and efficient operation.<\/p>\n<p>- Follow project specifications and plans to ensure proper execution of work according to safety standards.<\/p>\n<p>- Work collaboratively with other equipment operators, laborers, and supervisors to meet project goals and deadlines.<\/p>\n<p>- Adhere to safety protocols and contribute to maintaining a safe work environment.<\/p>\n<p>- Communicate effectively with the team to coordinate tasks and report any issues or delays.<\/p>\n<p>- Complete necessary documentation and reports related to equipment use, work hours, and materials.<\/p>\n<p>---<\/p>\n<p>Required Qualifications:<\/p>\n<p>- Minimum 5 years of experience operating a CAT D6 Dozer or similar equipment in construction or heavy equipment operations.<\/p>\n<p>- Proven ability to perform tasks such as grading, clearing, and leveling with a high degree of precision.<\/p>\n<p>- Strong knowledge of equipment safety procedures and standard operating practices.<\/p>\n<p>- Ability to read and interpret project plans, blueprints, and specifications.<\/p>\n<p>- Valid driver\u2019s license and clean driving record.<\/p>\n<p>- Ability to perform basic machine maintenance, including lubricating and servicing equipment.<\/p>\n<p>- Must pass a pre-employment drug screening and background check.<\/p><p><br><\/p>\n\n<p>Preferred Qualifications:<\/p>\n<p>- Experience working in remote locations or with short-term contract positions.<\/p>\n<p>- Knowledge of additional heavy equipment operations.<\/p><p><br><\/p>\n\n<p>Physical Requirements:<\/p>\n<p>- Ability to lift up to 50 lbs regularly.<\/p>\n<p>- Ability to stand, walk, bend, or sit for extended periods.<\/p>\n<p>- Comfortable working in varying weather conditions (heat, cold, dust).<\/p>\n<p><br><\/p>\n<p>Compensation and Benefits:<\/p>\n<p>- Competitive hourly rate based on experience.<\/p>\n<p>- Potential for overtime based on project needs.<\/p>\n<p>- Accommodation assistance and travel arrangements if applicable.<\/p>\n<p>- Opportunity to gain experience with a reputable construction project in Nevada.<\/p>\n<p><br><\/p>\n<p>If you meet the qualifications and are interested in contributing to a dynamic team for a short-term contract position, please apply with your resume and relevant certifications. <\/p>\n<p>We look forward to hearing from you!<\/p>","%category%":"Operations","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/203ca195d849-cat-d6-dozer-operator","%breezy_id%":"203ca195d849","%breezy_friendly_id%":"203ca195d849-cat-d6-dozer-operator","%breezy_created_date%":"2025-02-28T19:02:42.109Z","%breezy_updated_date%":"2025-02-28T19:04:25.111Z","%_wpgmp_location_city%":"Wells","%_wpgmp_location_state%":"NV","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Wells, NV, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"41.1115888","%_wpgmp_metabox_longitude%":"-114.96449","%rank_math_internal_links_processed%":"1"}},"id":2205,"infowindow_disable":false},{"source":"post","title":"Drill Operator &#8211; Mining","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Drill Operator &#8211; Mining\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Job Title: Drill Operator Location:&nbsp;Kingman,&nbsp;AZ Company:&nbsp;Turner Mining Group Position Type:&nbsp;Full-Time Salary:&nbsp;Competitive, based on experience Job Overview: Turner Mining&nbsp;Group is seeking&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/drill-operator-mining\/\" name=\"Drill Operator &#8211; Mining\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Job Title: Drill Operator Location:&nbsp;Kingman,&nbsp;AZ Company:&nbsp;Turner Mining Group Position Type:&nbsp;Full-Time Salary:&nbsp;Competitive, based on experience Job Overview: Turner Mining&nbsp;Group is seeking&hellip;","address":"Kingman, AZ, USA","location":{"lat":"35.1912977","city":"Kingman","state":"AZ","country":"United States","lng":"-114.0522845","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/drill-operator-mining\/","zoom":19,"extra_fields":{"post_excerpt":"Job Title: Drill Operator Location:&nbsp;Kingman,&nbsp;AZ Company:&nbsp;Turner Mining Group Position Type:&nbsp;Full-Time Salary:&nbsp;Competitive, based on experience Job Overview: Turner Mining&nbsp;Group is seeking&hellip;","post_content":"<h3><strong>Job Title: Drill Operator<\/strong><\/h3>\n<p><strong>Location:<\/strong>&nbsp;Kingman,&nbsp;AZ<\/p>\n<p><strong>Company:<\/strong>&nbsp;Turner Mining Group<\/p>\n<p><strong>Position Type:<\/strong>&nbsp;Full-Time<\/p>\n<p><strong>Salary:<\/strong>&nbsp;Competitive, based on experience<\/p>\n<h4><strong>Job Overview:<\/strong><\/h4>\n<p>Turner Mining&nbsp;Group is seeking experienced Drill Operators to join our mining team in Kingman, AZ. The ideal candidates will have hands-on experience operating drilling equipment. The role involves operating drilling rigs to support mining operations and ensuring that all drilling activities are performed safely and efficiently.<\/p>\n<h4><strong>Key Responsibilities:<\/strong><\/h4>\n<ul><li>Operate drilling rigs in a mining environment.<\/li><li>Perform pre-operational checks and routine maintenance on drilling equipment to ensure optimal performance.<\/li><li>Accurately interpret drill plans and follow specifications for drilling operations.<\/li><li>Monitor the drilling process, adjusting as necessary to ensure safety and efficiency.<\/li><li>Collaborate with other team members to coordinate drilling activities and support overall mining operations.<\/li><li>Maintain accurate records of drilling operations, including depth, time, and any issues encountered.<\/li><li>Ensure compliance with all safety regulations and company policies.<\/li><li>Troubleshoot and resolve operational issues as they arise.<\/li><li>Assist in training and mentoring less experienced drill operators.<\/li><li>Perform additional tasks as assigned by supervisors.<\/li><\/ul>\n<h4><strong>Qualifications:<\/strong><\/h4>\n<ul><li>High school diploma or equivalent.<\/li><li>Proven experience as a drill operator.<\/li><li>Strong understanding of drilling techniques and equipment maintenance.<\/li><li>Ability to read and interpret drilling plans, blueprints, and technical manuals.<\/li><li>Excellent physical condition, with the ability to work in various weather conditions.<\/li><li>Strong problem-solving skills and attention to detail.<\/li><li>Good communication and teamwork abilities.<\/li><li>Commitment to maintaining a safe work environment.<\/li><li>Valid driver\u2019s license and reliable transportation.<\/li><\/ul>\n<h4><strong>Preferred Qualifications:<\/strong><\/h4>\n<ul><li>Certification or specialized training in drilling operations.<\/li><li>Previous experience in a mining environment.<\/li><li>Familiarity with drilling software and technology.<\/li><\/ul>\n<h4><strong>Benefits:<\/strong><\/h4>\n<ul><li>Competitive salary and benefits package.<\/li><li>Opportunities for career advancement and professional development.<\/li><li>Comprehensive health, dental, and vision insurance.<\/li><li>Retirement savings plan with company match.<\/li><li>Paid time off and holidays.<\/li><li>Supportive and collaborative work environment.<\/li><\/ul>","post_title":"Drill Operator &#8211; Mining","post_link":"https:\/\/turnerstaffing.com\/position\/drill-operator-mining\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Associate","%location_country%":"United States","%location_city%":"Kingman","%location_state_id%":"AZ","%location_state_name%":"Arizona","%location_city_state%":"Kingman, AZ","%education%":"Unspecified","%department%":"Operations","%description%":"<h3><strong>Job Title: Drill Operator<\/strong><\/h3>\n<p><strong>Location:<\/strong>&nbsp;Kingman,&nbsp;AZ<\/p>\n<p><strong>Company:<\/strong>&nbsp;Turner Mining Group<\/p>\n<p><strong>Position Type:<\/strong>&nbsp;Full-Time<\/p>\n<p><strong>Salary:<\/strong>&nbsp;Competitive, based on experience<\/p>\n<h4><strong>Job Overview:<\/strong><\/h4>\n<p>Turner Mining&nbsp;Group is seeking experienced Drill Operators to join our mining team in Kingman, AZ. The ideal candidates will have hands-on experience operating drilling equipment. The role involves operating drilling rigs to support mining operations and ensuring that all drilling activities are performed safely and efficiently.<\/p>\n<h4><strong>Key Responsibilities:<\/strong><\/h4>\n<ul><li>Operate drilling rigs in a mining environment.<\/li><li>Perform pre-operational checks and routine maintenance on drilling equipment to ensure optimal performance.<\/li><li>Accurately interpret drill plans and follow specifications for drilling operations.<\/li><li>Monitor the drilling process, adjusting as necessary to ensure safety and efficiency.<\/li><li>Collaborate with other team members to coordinate drilling activities and support overall mining operations.<\/li><li>Maintain accurate records of drilling operations, including depth, time, and any issues encountered.<\/li><li>Ensure compliance with all safety regulations and company policies.<\/li><li>Troubleshoot and resolve operational issues as they arise.<\/li><li>Assist in training and mentoring less experienced drill operators.<\/li><li>Perform additional tasks as assigned by supervisors.<\/li><\/ul>\n<h4><strong>Qualifications:<\/strong><\/h4>\n<ul><li>High school diploma or equivalent.<\/li><li>Proven experience as a drill operator.<\/li><li>Strong understanding of drilling techniques and equipment maintenance.<\/li><li>Ability to read and interpret drilling plans, blueprints, and technical manuals.<\/li><li>Excellent physical condition, with the ability to work in various weather conditions.<\/li><li>Strong problem-solving skills and attention to detail.<\/li><li>Good communication and teamwork abilities.<\/li><li>Commitment to maintaining a safe work environment.<\/li><li>Valid driver\u2019s license and reliable transportation.<\/li><\/ul>\n<h4><strong>Preferred Qualifications:<\/strong><\/h4>\n<ul><li>Certification or specialized training in drilling operations.<\/li><li>Previous experience in a mining environment.<\/li><li>Familiarity with drilling software and technology.<\/li><\/ul>\n<h4><strong>Benefits:<\/strong><\/h4>\n<ul><li>Competitive salary and benefits package.<\/li><li>Opportunities for career advancement and professional development.<\/li><li>Comprehensive health, dental, and vision insurance.<\/li><li>Retirement savings plan with company match.<\/li><li>Paid time off and holidays.<\/li><li>Supportive and collaborative work environment.<\/li><\/ul>","%category%":"Operations","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/dd6894e17546-drill-operator-mining","%breezy_id%":"dd6894e17546","%breezy_friendly_id%":"dd6894e17546-drill-operator-mining","%breezy_created_date%":"2025-02-24T21:05:14.005Z","%breezy_updated_date%":"2025-02-24T21:05:59.430Z","%_wpgmp_location_city%":"Kingman","%_wpgmp_location_state%":"AZ","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Kingman, AZ, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"35.1912977","%_wpgmp_metabox_longitude%":"-114.0522845","%rank_math_internal_links_processed%":"1"}},"id":2198,"infowindow_disable":false},{"source":"post","title":"IT Service Desk Technician","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    IT Service Desk Technician\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Position Description: The successful candidate will be responsible for the configuration, installation, troubleshooting and repair of personal computers, printers, telephones,&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/it-service-desk-technician-2\/\" name=\"IT Service Desk Technician\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Position Description: The successful candidate will be responsible for the configuration, installation, troubleshooting and repair of personal computers, printers, telephones,&hellip;","address":"Winnemucca, NV, USA","location":{"lat":"40.9728274","city":"Winnemucca","state":"NV","country":"United States","lng":"-117.7357354","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/it-service-desk-technician-2\/","zoom":19,"extra_fields":{"post_excerpt":"Position Description: The successful candidate will be responsible for the configuration, installation, troubleshooting and repair of personal computers, printers, telephones,&hellip;","post_content":"<p><strong><span style=\"color:#2f5496\">Position Description:<\/span><\/strong><\/p><p><span style=\"color:#555555\">The successful candidate will be responsible for the configuration, installation, troubleshooting and repair of personal computers, printers, telephones, mobile devices and data communications equipment; configuration and support of mobile devices; installation, configuration and support of desktop software systems; troubleshooting and resolving software and hardware problems; rotate through the role of on-call Help Desk technician on a periodic basis; perform other duties as assigned.<\/span><\/p><p><strong><span style=\"color:#2f5496\">Key Responsibilities:<\/span><\/strong><\/p><ul><li><span style=\"color:#555555\">Works at the Help Desk receives Help Desk tickets and telephone calls focusing on answering computer user requests for assistance, problem solving with a goal of first call resolution, providing troubleshooting and resolving of software, hardware, mobile and network problems.<\/span><\/li><li><span style=\"color:#555555\">Daily maintenance tasks, imaging computers and remediate broken clients<\/span><\/li><li><span style=\"color:#555555\">Assesses and collects essential issue data relative to problem and customer information for the dispatching a work to next tier support.<\/span><\/li><li><span style=\"color:#555555\">Provides first and second-level technical customer support; first level of support duties are receiving trouble calls via Help Desk tickets, telephone and e-mail and resolving issues within scope of role; if problems need a higher level support, the Help Desk technician will dispatch a service ticket to the appropriate higher level support personnel.<\/span><\/li><li><span style=\"color:#555555\">Provide local hands on support when higher level support needs physical assistance; second-level support is solving routine technical problems remotely from the Help Desk.<\/span><\/li><li><span style=\"color:#555555\">Responsible for day to day manning of the Help Desk ticketing system for all computer related trouble reported by local end users.<\/span><\/li><\/ul><p><strong><span style=\"color:#2f5496\">Qualifications:<\/span><\/strong><\/p><ul><li><span style=\"color:#555555\">Two (2) years of PC Technician experience in a business networking environment required<\/span><\/li><li><span style=\"color:#555555\">BS in Computer Sciences preferred<\/span><\/li><li><span style=\"color:#555555\">Microsoft MCSA or MCSE and A+ certifications preferred<\/span><\/li><li><span style=\"color:#555555\">Ability to lift and carry 50 pounds required<\/span><\/li><li><span style=\"color:#555555\">Ability to travel locally routinely required<\/span><\/li><li><span style=\"color:#555555\">Exceptional customer service\/interpersonal skills required<\/span><\/li><li><span style=\"color:#555555\">Demonstrated extensive knowledge of personal computers in a networked environment including data and telecommunications equipment required<\/span><\/li><li><span style=\"color:#555555\">Knowledge of and experience with, local area networks and associated protocols and equipment. Specifically, Microsoft Windows, IOS environments, mobile devices, firewall technology and TCP\/IP. Familiarity of Cisco networking equipment preferred<\/span><\/li><\/ul><p><strong><span style=\"color:#2f5496\">What we can Offer You <\/span><\/strong><\/p><ul><li><span style=\"color:#555555\">A comprehensive compensation package including benefits<\/span><\/li><li><span style=\"color:#555555\">Ability to make a difference and lasting impact<\/span><\/li><li><span style=\"color:#555555\">Work in a dynamic, collaborative, progressive, and high-performing team<\/span><\/li><li><span style=\"color:#555555\">An Opportunity to transform Traditional Mining into the future of Digital Mining<\/span><\/li><li><span style=\"color:#555555\">Opportunities to grow and learn with industry colleagues are endless<\/span><\/li><li>Must be authorized to work in the US without work visa sponsorship<\/li><\/ul>","post_title":"IT Service Desk Technician","post_link":"https:\/\/turnerstaffing.com\/position\/it-service-desk-technician-2\/","post_featured_image":"","post_categories":"","post_tags":"","%location_country%":"United States","%location_city%":"Winnemucca","%location_state_id%":"NV","%location_city_state%":"Winnemucca, NV","%description%":"<p><strong><span style=\"color:#2f5496;\">Position Description:<\/span><\/strong><\/p><p><span style=\"color:#555555;\">The successful candidate will be responsible for the configuration, installation, troubleshooting and repair of personal computers, printers, telephones, mobile devices and data communications equipment; configuration and support of mobile devices; installation, configuration and support of desktop software systems; troubleshooting and resolving software and hardware problems; rotate through the role of on-call Help Desk technician on a periodic basis; perform other duties as assigned.<\/span><\/p><p><strong><span style=\"color:#2f5496;\">Key Responsibilities:<\/span><\/strong><\/p><ul><li><span style=\"color:#555555;\">Works at the Help Desk receives Help Desk tickets and telephone calls focusing on answering computer user requests for assistance, problem solving with a goal of first call resolution, providing troubleshooting and resolving of software, hardware, mobile and network problems.<\/span><\/li><li><span style=\"color:#555555;\">Daily maintenance tasks, imaging computers and remediate broken clients<\/span><\/li><li><span style=\"color:#555555;\">Assesses and collects essential issue data relative to problem and customer information for the dispatching a work to next tier support.<\/span><\/li><li><span style=\"color:#555555;\">Provides first and second-level technical customer support; first level of support duties are receiving trouble calls via Help Desk tickets, telephone and e-mail and resolving issues within scope of role; if problems need a higher level support, the Help Desk technician will dispatch a service ticket to the appropriate higher level support personnel.<\/span><\/li><li><span style=\"color:#555555;\">Provide local hands on support when higher level support needs physical assistance; second-level support is solving routine technical problems remotely from the Help Desk.<\/span><\/li><li><span style=\"color:#555555;\">Responsible for day to day manning of the Help Desk ticketing system for all computer related trouble reported by local end users.<\/span><\/li><\/ul><p><strong><span style=\"color:#2f5496;\">Qualifications:<\/span><\/strong><\/p><ul><li><span style=\"color:#555555;\">Two (2) years of PC Technician experience in a business networking environment required<\/span><\/li><li><span style=\"color:#555555;\">BS in Computer Sciences preferred<\/span><\/li><li><span style=\"color:#555555;\">Microsoft MCSA or MCSE and A+ certifications preferred<\/span><\/li><li><span style=\"color:#555555;\">Ability to lift and carry 50 pounds required<\/span><\/li><li><span style=\"color:#555555;\">Ability to travel locally routinely required<\/span><\/li><li><span style=\"color:#555555;\">Exceptional customer service\/interpersonal skills required<\/span><\/li><li><span style=\"color:#555555;\">Demonstrated extensive knowledge of personal computers in a networked environment including data and telecommunications equipment required<\/span><\/li><li><span style=\"color:#555555;\">Knowledge of and experience with, local area networks and associated protocols and equipment. Specifically, Microsoft Windows, IOS environments, mobile devices, firewall technology and TCP\/IP. Familiarity of Cisco networking equipment preferred<\/span><\/li><\/ul><p><strong><span style=\"color:#2f5496;\">What we can Offer You <\/span><\/strong><\/p><ul><li><span style=\"color:#555555;\">A comprehensive compensation package including benefits<\/span><\/li><li><span style=\"color:#555555;\">Ability to make a difference and lasting impact<\/span><\/li><li><span style=\"color:#555555;\">Work in a dynamic, collaborative, progressive, and high-performing team<\/span><\/li><li><span style=\"color:#555555;\">An Opportunity to transform Traditional Mining into the future of Digital Mining<\/span><\/li><li><span style=\"color:#555555;\">Opportunities to grow and learn with industry colleagues are endless<\/span><\/li><li>Must be authorized to work in the US without work visa sponsorship<\/li><\/ul>","%application_url%":"https:\/\/jobs.crelate.com\/portal\/turnerstaffinggroup\/job\/z1fnpcnao64s9mbqtionip5xae","%crelate_id%":"z1fnpcnao64s9mbqtionip5xae","%crelate_created_date%":"2025-02-20T15:41:52.36Z","%crelate_updated_date%":"2025-03-24T21:03:31.42Z","%_wpgmp_location_city%":"Winnemucca","%_wpgmp_location_state%":"NV","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Winnemucca, NV, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"40.9728274","%_wpgmp_metabox_longitude%":"-117.7357354","%rank_math_internal_links_processed%":"1"}},"id":2196,"infowindow_disable":false},{"source":"post","title":"Geologist","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Geologist\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    We are seeking a highly motivated and detail-oriented Core Logging Geologist to join our dynamic team. As a Core Logging&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/geologist-2\/\" name=\"Geologist\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"We are seeking a highly motivated and detail-oriented Core Logging Geologist to join our dynamic team. As a Core Logging&hellip;","address":"Elko, NV, USA","location":{"lat":"40.8436459","city":"Elko","state":"NV","country":"United States","lng":"-115.7526187","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/geologist-2\/","zoom":19,"extra_fields":{"post_excerpt":"We are seeking a highly motivated and detail-oriented Core Logging Geologist to join our dynamic team. As a Core Logging&hellip;","post_content":"<p style=\"color:#374151\">We are seeking a highly motivated and detail-oriented Core Logging Geologist to join our dynamic team. As a Core Logging Geologist, you will play a crucial role in the exploration and development of mineral resources. This position involves a combination of field and office work, requiring expertise in drill core logging and sampling, digital data entry, collation and interpretation of geological information, geologic mapping, and effective communication with drill contractors and fellow geologists.<\/p><p style=\"color:#374151\"><span style=\"color:var(--tw-prose-bold)\">Responsibilities:<\/span><\/p><ol><li><p><span style=\"color:var(--tw-prose-bold)\">Drill Core Logging and Sampling:<\/span><\/p><ul><li>Conduct detailed and accurate logging of drill core samples.<\/li><li>Implement best practices for core sampling, ensuring high-quality data collection.<\/li><li>Collaborate with drilling teams to optimize core recovery and maintain data integrity.<\/li><\/ul><\/li><li><p><span style=\"color:var(--tw-prose-bold)\">Digital Data Entry:<\/span><\/p><ul><li>Perform timely and precise digital entry of geological information using relevant software.<\/li><li>Organize and manage databases to facilitate efficient data retrieval and analysis.<\/li><li>Maintain a high level of accuracy in data entry to support reliable geological interpretations.<\/li><\/ul><\/li><li><p><span style=\"color:var(--tw-prose-bold)\">Collation and Interpretation of Data:<\/span><\/p><ul><li>Analyze geological data to identify patterns, trends, and potential mineralization.<\/li><li>Collaborate with cross-functional teams to integrate geological findings into broader project objectives.<\/li><li>Contribute to the development of geological models and interpretations.<\/li><\/ul><\/li><li><p><span style=\"color:var(--tw-prose-bold)\">Liaising with Drill Contractors and Other Geologists:<\/span><\/p><ul><li>Establish and maintain effective communication with drill contractors to ensure project objectives are met.<\/li><li>Collaborate with fellow geologists to share insights, coordinate activities, and enhance overall project understanding.<\/li><li>Provide clear and concise updates to project stakeholders, fostering a collaborative working environment.<\/li><\/ul><\/li><li><p><span style=\"color:var(--tw-prose-bold)\">Geologic Mapping:<\/span><\/p><ul><li>Conduct geologic mapping to enhance the understanding of the project area.<\/li><li>Utilize mapping data to contribute to geological models and exploration strategies.<\/li><li>Document and communicate mapping findings to support broader geological interpretations.<\/li><\/ul><\/li><\/ol><p style=\"color:#374151\"><span style=\"color:var(--tw-prose-bold)\">Qualifications:<\/span><\/p><ul><li>Bachelor's or higher degree in Geology, Earth Sciences, or a related field.<\/li><li>Proven experience in drill core logging and sampling.<\/li><li>Proficiency in digital data entry and geological software.<\/li><li>Strong analytical and problem-solving skills.<\/li><li>Excellent communication and interpersonal skills.<\/li><li>Ability to work collaboratively in a team and independently in the field.<\/li><li>Familiarity with geologic mapping techniques and tools.<\/li><li>Must be authorized to work in the US without work visa sponsorship.<\/li><\/ul>","post_title":"Geologist","post_link":"https:\/\/turnerstaffing.com\/position\/geologist-2\/","post_featured_image":"","post_categories":"","post_tags":"","%location_country%":"United States","%location_city%":"Elko","%location_state_id%":"NV","%location_city_state%":"Elko, NV","%description%":"<p style=\"color:#374151;\">We are seeking a highly motivated and detail-oriented Core Logging Geologist to join our dynamic team. As a Core Logging Geologist, you will play a crucial role in the exploration and development of mineral resources. This position involves a combination of field and office work, requiring expertise in drill core logging and sampling, digital data entry, collation and interpretation of geological information, geologic mapping, and effective communication with drill contractors and fellow geologists.<\/p><p style=\"color:#374151;\"><span style=\"color:var(--tw-prose-bold);\">Responsibilities:<\/span><\/p><ol><li><p><span style=\"color:var(--tw-prose-bold);\">Drill Core Logging and Sampling:<\/span><\/p><ul><li>Conduct detailed and accurate logging of drill core samples.<\/li><li>Implement best practices for core sampling, ensuring high-quality data collection.<\/li><li>Collaborate with drilling teams to optimize core recovery and maintain data integrity.<\/li><\/ul><\/li><li><p><span style=\"color:var(--tw-prose-bold);\">Digital Data Entry:<\/span><\/p><ul><li>Perform timely and precise digital entry of geological information using relevant software.<\/li><li>Organize and manage databases to facilitate efficient data retrieval and analysis.<\/li><li>Maintain a high level of accuracy in data entry to support reliable geological interpretations.<\/li><\/ul><\/li><li><p><span style=\"color:var(--tw-prose-bold);\">Collation and Interpretation of Data:<\/span><\/p><ul><li>Analyze geological data to identify patterns, trends, and potential mineralization.<\/li><li>Collaborate with cross-functional teams to integrate geological findings into broader project objectives.<\/li><li>Contribute to the development of geological models and interpretations.<\/li><\/ul><\/li><li><p><span style=\"color:var(--tw-prose-bold);\">Liaising with Drill Contractors and Other Geologists:<\/span><\/p><ul><li>Establish and maintain effective communication with drill contractors to ensure project objectives are met.<\/li><li>Collaborate with fellow geologists to share insights, coordinate activities, and enhance overall project understanding.<\/li><li>Provide clear and concise updates to project stakeholders, fostering a collaborative working environment.<\/li><\/ul><\/li><li><p><span style=\"color:var(--tw-prose-bold);\">Geologic Mapping:<\/span><\/p><ul><li>Conduct geologic mapping to enhance the understanding of the project area.<\/li><li>Utilize mapping data to contribute to geological models and exploration strategies.<\/li><li>Document and communicate mapping findings to support broader geological interpretations.<\/li><\/ul><\/li><\/ol><p style=\"color:#374151;\"><span style=\"color:var(--tw-prose-bold);\">Qualifications:<\/span><\/p><ul><li>Bachelor's or higher degree in Geology, Earth Sciences, or a related field.<\/li><li>Proven experience in drill core logging and sampling.<\/li><li>Proficiency in digital data entry and geological software.<\/li><li>Strong analytical and problem-solving skills.<\/li><li>Excellent communication and interpersonal skills.<\/li><li>Ability to work collaboratively in a team and independently in the field.<\/li><li>Familiarity with geologic mapping techniques and tools.<\/li><li>Must be authorized to work in the US without work visa sponsorship.<\/li><\/ul>","%application_url%":"https:\/\/jobs.crelate.com\/portal\/turnerstaffinggroup\/job\/wcyp9n54dbiis7b3shoospkimh","%crelate_id%":"wcyp9n54dbiis7b3shoospkimh","%crelate_created_date%":"2024-02-14T18:12:41.04Z","%crelate_updated_date%":"2025-03-17T13:26:12.49Z","%_wpgmp_location_city%":"Elko","%_wpgmp_location_state%":"NV","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Elko, NV, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"40.8436459","%_wpgmp_metabox_longitude%":"-115.7526187","%rank_math_internal_links_processed%":"1"}},"id":2195,"infowindow_disable":false},{"source":"post","title":"Utility Pipe Superintendent","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Utility Pipe Superintendent\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Turner Staffing Group is partnered with a grading company looking for a utility pipe superintendent!&nbsp; DescriptionAre you a motivated and&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/utility-pipe-superintendent\/\" name=\"Utility Pipe Superintendent\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Turner Staffing Group is partnered with a grading company looking for a utility pipe superintendent!&nbsp; DescriptionAre you a motivated and&hellip;","address":"Charlotte, NC, USA","location":{"lat":"35.2215548","city":"Charlotte","state":"NC","country":"United States","lng":"-80.840116","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/utility-pipe-superintendent\/","zoom":19,"extra_fields":{"post_excerpt":"Turner Staffing Group is partnered with a grading company looking for a utility pipe superintendent!&nbsp; DescriptionAre you a motivated and&hellip;","post_content":"<p>Turner Staffing Group is partnered with a grading company looking for a utility pipe superintendent!&nbsp;<\/p>\n<p><strong>Description<\/strong><br>Are you a motivated and experienced Pipe Superintendent ready to lead a pipe crew in delivering top-quality work on a variety of exciting projects? If you\u2019re professional with a passion for excellence and leadership, we want you on our team to make a difference in The Carolinas.<\/p>\n<p>Please note that the job description provided below offers a general overview of the role\u2019s responsibilities and expectations, rather than an exhaustive list of tasks.<\/p>\n<p><strong>What our team needs from you:<\/strong><\/p>\n<ul><li>Supervise operations, direct sub-contractors and maintain material inventory.<\/li><li>Operate motor vehicles and equipment necessary for completion of projects.<\/li><li>Attend training at the Academy.<\/li><li>Utilize the company's Core Values in daily duties.<\/li><li>Understand, interpret, and follow goals and directions from a foreman or superintendent.<\/li><li>Communicate professionally with everyone on site, including but not limited to supervisors, teammates, contractors, clients, and vendor partners.<\/li><li>Maintain attendance at work, including presence at work during regular work hours or another schedule as may be assigned by the foreman or superintendent. Acceptance of overtime assignments may also be required in order to meet operational needs.<\/li><\/ul>\n<p><strong>Other Duties &amp; Responsibilities:<\/strong><\/p>\n<ul><li>Perform other various assignments as assigned.<\/li><\/ul>\n<p><strong>Experience &amp; Requirements<\/strong><\/p>\n<ul><li>Experience with water, sanitary sewer and storm drainage construction specifications, techniques and installation.<\/li><li>Ability to read blueprints, plans and specifications for installation.<\/li><li>OSHA compliant with trenching, shoring, excavation and confined space entry.<\/li><li>Understand basic survey line, grade and slope.<\/li><li>A Motor Vehicle Report (MVR) will be run on anyone considered for this position.<\/li><li>Must be 18 years of age or older.<\/li><li>Must have reliable transportation.<\/li><li>Must be highly motivated and willing to learn.<\/li><li>Must be able to understand project goals and direction.<\/li><li>Must enjoy working outside in all weather conditions.<\/li><li>Must pass a pre-employment drug test, fit-for-duty physical, and background screening.<\/li><li>Must be able to communicate effectively with directors, supervisors, and teammates and be a team player.<\/li><li>Must be willing to work Monday through Friday 7 AM-5:30 PM, or another schedule as may be assigned by the foreman or superintendent, as well as Saturdays when needed.<\/li><\/ul>\n<p><strong>Essential Physical Demands of Work Environment, With or Without a Reasonable Accommodation:<\/strong><\/p>\n<ul><li>Able to walk through varied terrain.<\/li><li>Able to lift 40 lbs. (unassisted) to 80 lbs. (assisted) on a regular basis.<\/li><li>Able to lift, carry, and hold building materials, tools, and supplies.<\/li><li>Able to perform job responsibilities outdoors, in all types of weather conditions.<\/li><li>Able to maintain constant alertness and situational awareness while on the job site.<\/li><li>Able to climb on and off equipment safely while maintaining three (3) points of contact.<\/li><li>Able to use hands, arms, and feet for repetitive lifting and carrying of construction materials.<\/li><li>Able to stand\/sit for extended periods of time, as well as stoop, kneel, walk, bend, crouch, lift, and crawl as required to perform essential duties.<\/li><li>Able to communicate audibly and visually while exposed to varying levels of noise, dust and substances commonly found on construction sites.<\/li><li>Any other physical demand the assigned duties require.<\/li><\/ul>\n<p><strong>What\u2019s in it for you:<\/strong><\/p>\n<ul><li>Company Truck<\/li><li>Profit Sharing Program<\/li><li>401(k) Plan with Company Match<\/li><li>Medical Insurance<\/li><li>Voluntary Dental, Vision &amp; Life Insurances<\/li><li>Voluntary Long-Term Disability<\/li><li>Competitive Pay (based on experience)<\/li><li>Group Term Life<\/li><li>Short-Term Disability<\/li><li>Paid Vacation, Holidays, Bereavement &amp; Maternity\/Paternity Leave<\/li><li>Free Training Programs at the Academy:<ul><li>CAT Simulators<\/li><li>Classroom Training<\/li><li>Professional Development<\/li><li>Safety Training<\/li><li>First Aid Training<\/li><li>MSHA Training<\/li><\/ul><\/li><\/ul>\n<p>The company operates within a 65-mile radius from Charlotte, North Carolina. By applying for this position, you acknowledge our operation radius and understand your commute could reach up to one (1) hour. Teammates are asked to move job sites as project needs change and occasionally report to the Academy for training. All applicants to whom a conditional offer of employment is made shall undergo and pass a pre-employment screening, including drug test, background check, and a fit-for-duty exam prior to beginning work. The company is a drug-free workplace.<\/p>","post_title":"Utility Pipe Superintendent","post_link":"https:\/\/turnerstaffing.com\/position\/utility-pipe-superintendent\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"","%location_country%":"United States","%location_city%":"Charlotte","%location_state_id%":"NC","%location_state_name%":"North Carolina","%location_city_state%":"Charlotte, NC","%education%":"","%department%":"","%description%":"<p>Turner Staffing Group is partnered with a grading company looking for a utility pipe superintendent!&nbsp;<\/p>\n<p><strong>Description<\/strong><br>Are you a motivated and experienced Pipe Superintendent ready to lead a pipe crew in delivering top-quality work on a variety of exciting projects? If you\u2019re professional with a passion for excellence and leadership, we want you on our team to make a difference in The Carolinas.<\/p>\n<p>Please note that the job description provided below offers a general overview of the role\u2019s responsibilities and expectations, rather than an exhaustive list of tasks.<\/p>\n<p><strong>What our team needs from you:<\/strong><\/p>\n<ul><li>Supervise operations, direct sub-contractors and maintain material inventory.<\/li><li>Operate motor vehicles and equipment necessary for completion of projects.<\/li><li>Attend training at the Academy.<\/li><li>Utilize the company's Core Values in daily duties.<\/li><li>Understand, interpret, and follow goals and directions from a foreman or superintendent.<\/li><li>Communicate professionally with everyone on site, including but not limited to supervisors, teammates, contractors, clients, and vendor partners.<\/li><li>Maintain attendance at work, including presence at work during regular work hours or another schedule as may be assigned by the foreman or superintendent. Acceptance of overtime assignments may also be required in order to meet operational needs.<\/li><\/ul>\n<p><strong>Other Duties &amp; Responsibilities:<\/strong><\/p>\n<ul><li>Perform other various assignments as assigned.<\/li><\/ul>\n<p><strong>Experience &amp; Requirements<\/strong><\/p>\n<ul><li>Experience with water, sanitary sewer and storm drainage construction specifications, techniques and installation.<\/li><li>Ability to read blueprints, plans and specifications for installation.<\/li><li>OSHA compliant with trenching, shoring, excavation and confined space entry.<\/li><li>Understand basic survey line, grade and slope.<\/li><li>A Motor Vehicle Report (MVR) will be run on anyone considered for this position.<\/li><li>Must be 18 years of age or older.<\/li><li>Must have reliable transportation.<\/li><li>Must be highly motivated and willing to learn.<\/li><li>Must be able to understand project goals and direction.<\/li><li>Must enjoy working outside in all weather conditions.<\/li><li>Must pass a pre-employment drug test, fit-for-duty physical, and background screening.<\/li><li>Must be able to communicate effectively with directors, supervisors, and teammates and be a team player.<\/li><li>Must be willing to work Monday through Friday 7 AM-5:30 PM, or another schedule as may be assigned by the foreman or superintendent, as well as Saturdays when needed.<\/li><\/ul>\n<p><strong>Essential Physical Demands of Work Environment, With or Without a Reasonable Accommodation:<\/strong><\/p>\n<ul><li>Able to walk through varied terrain.<\/li><li>Able to lift 40 lbs. (unassisted) to 80 lbs. (assisted) on a regular basis.<\/li><li>Able to lift, carry, and hold building materials, tools, and supplies.<\/li><li>Able to perform job responsibilities outdoors, in all types of weather conditions.<\/li><li>Able to maintain constant alertness and situational awareness while on the job site.<\/li><li>Able to climb on and off equipment safely while maintaining three (3) points of contact.<\/li><li>Able to use hands, arms, and feet for repetitive lifting and carrying of construction materials.<\/li><li>Able to stand\/sit for extended periods of time, as well as stoop, kneel, walk, bend, crouch, lift, and crawl as required to perform essential duties.<\/li><li>Able to communicate audibly and visually while exposed to varying levels of noise, dust and substances commonly found on construction sites.<\/li><li>Any other physical demand the assigned duties require.<\/li><\/ul>\n<p><strong>What\u2019s in it for you:<\/strong><\/p>\n<ul><li>Company Truck<\/li><li>Profit Sharing Program<\/li><li>401(k) Plan with Company Match<\/li><li>Medical Insurance<\/li><li>Voluntary Dental, Vision &amp; Life Insurances<\/li><li>Voluntary Long-Term Disability<\/li><li>Competitive Pay (based on experience)<\/li><li>Group Term Life<\/li><li>Short-Term Disability<\/li><li>Paid Vacation, Holidays, Bereavement &amp; Maternity\/Paternity Leave<\/li><li>Free Training Programs at the Academy:<ul><li>CAT Simulators<\/li><li>Classroom Training<\/li><li>Professional Development<\/li><li>Safety Training<\/li><li>First Aid Training<\/li><li>MSHA Training<\/li><\/ul><\/li><\/ul>\n<p>The company operates within a 65-mile radius from Charlotte, North Carolina. By applying for this position, you acknowledge our operation radius and understand your commute could reach up to one (1) hour. Teammates are asked to move job sites as project needs change and occasionally report to the Academy for training. All applicants to whom a conditional offer of employment is made shall undergo and pass a pre-employment screening, including drug test, background check, and a fit-for-duty exam prior to beginning work. The company is a drug-free workplace.<\/p>","%category%":"","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/70d7e7f27703-utility-pipe-superintendent","%breezy_id%":"70d7e7f27703","%breezy_friendly_id%":"70d7e7f27703-utility-pipe-superintendent","%breezy_created_date%":"2025-02-20T19:19:21.491Z","%breezy_updated_date%":"2025-02-21T02:02:00.811Z","%_wpgmp_location_city%":"Charlotte","%_wpgmp_location_state%":"NC","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Charlotte, NC, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"35.2215548","%_wpgmp_metabox_longitude%":"-80.840116","%rank_math_internal_links_processed%":"1"}},"id":2192,"infowindow_disable":false},{"source":"post","title":"Geologist","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Geologist\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    We are seeking a highly motivated and detail-oriented Core Logging Geologist to join our dynamic team. As a Core Logging&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/geologist\/\" name=\"Geologist\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"We are seeking a highly motivated and detail-oriented Core Logging Geologist to join our dynamic team. As a Core Logging&hellip;","address":"Elko, NV, USA","location":{"lat":"40.8436459","city":"Elko","state":"NV","country":"United States","lng":"-115.7526187","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/geologist\/","zoom":19,"extra_fields":{"post_excerpt":"We are seeking a highly motivated and detail-oriented Core Logging Geologist to join our dynamic team. As a Core Logging&hellip;","post_content":"<p>We are seeking a highly motivated and detail-oriented Core Logging Geologist to join our dynamic team. As a Core Logging Geologist, you will play a crucial role in the exploration and development of mineral resources. This position involves a combination of field and office work, requiring expertise in drill core logging and sampling, digital data entry, collation and interpretation of geological information, geologic mapping, and effective communication with drill contractors and fellow geologists.<\/p>\n<p>Responsibilities:<\/p>\n<ol><li>Drill Core Logging and Sampling:<p><\/p><ul><li>Conduct detailed and accurate logging of drill core samples.<\/li><li>Implement best practices for core sampling, ensuring high-quality data collection.<\/li><li>Collaborate with drilling teams to optimize core recovery and maintain data integrity.<\/li><\/ul><\/li><li>Digital Data Entry:<p><\/p><ul><li>Perform timely and precise digital entry of geological information using relevant software.<\/li><li>Organize and manage databases to facilitate efficient data retrieval and analysis.<\/li><li>Maintain a high level of accuracy in data entry to support reliable geological interpretations.<\/li><\/ul><\/li><li>Collation and Interpretation of Data:<p><\/p><ul><li>Analyze geological data to identify patterns, trends, and potential mineralization.<\/li><li>Collaborate with cross-functional teams to integrate geological findings into broader project objectives.<\/li><li>Contribute to the development of geological models and interpretations.<\/li><\/ul><\/li><li>Liaising with Drill Contractors and Other Geologists:<p><\/p><ul><li>Establish and maintain effective communication with drill contractors to ensure project objectives are met.<\/li><li>Collaborate with fellow geologists to share insights, coordinate activities, and enhance overall project understanding.<\/li><li>Provide clear and concise updates to project stakeholders, fostering a collaborative working environment.<\/li><\/ul><\/li><li>Geologic Mapping:<p><\/p><ul><li>Conduct geologic mapping to enhance the understanding of the project area.<\/li><li>Utilize mapping data to contribute to geological models and exploration strategies.<\/li><li>Document and communicate mapping findings to support broader geological interpretations.<\/li><\/ul><\/li><\/ol>\n<p>Qualifications:<\/p>\n<ul><li>Bachelor's or higher degree in Geology, Earth Sciences, or a related field.<\/li><li>Proven experience in drill core logging and sampling.<\/li><li>Proficiency in digital data entry and geological software.<\/li><li>Strong analytical and problem-solving skills.<\/li><li>Excellent communication and interpersonal skills.<\/li><li>Ability to work collaboratively in a team and independently in the field.<\/li><li>Familiarity with geologic mapping techniques and tools.<\/li><li>Must be authorized to work in the US without work visa sponsorship.<\/li><\/ul>","post_title":"Geologist","post_link":"https:\/\/turnerstaffing.com\/position\/geologist\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"","%location_country%":"United States","%location_city%":"Elko","%location_state_id%":"NV","%location_state_name%":"Nevada","%location_city_state%":"Elko, NV","%education%":"","%department%":"","%description%":"<p>We are seeking a highly motivated and detail-oriented Core Logging Geologist to join our dynamic team. As a Core Logging Geologist, you will play a crucial role in the exploration and development of mineral resources. This position involves a combination of field and office work, requiring expertise in drill core logging and sampling, digital data entry, collation and interpretation of geological information, geologic mapping, and effective communication with drill contractors and fellow geologists.<\/p>\n<p>Responsibilities:<\/p>\n<ol><li>Drill Core Logging and Sampling:<p><\/p><ul><li>Conduct detailed and accurate logging of drill core samples.<\/li><li>Implement best practices for core sampling, ensuring high-quality data collection.<\/li><li>Collaborate with drilling teams to optimize core recovery and maintain data integrity.<\/li><\/ul><\/li><li>Digital Data Entry:<p><\/p><ul><li>Perform timely and precise digital entry of geological information using relevant software.<\/li><li>Organize and manage databases to facilitate efficient data retrieval and analysis.<\/li><li>Maintain a high level of accuracy in data entry to support reliable geological interpretations.<\/li><\/ul><\/li><li>Collation and Interpretation of Data:<p><\/p><ul><li>Analyze geological data to identify patterns, trends, and potential mineralization.<\/li><li>Collaborate with cross-functional teams to integrate geological findings into broader project objectives.<\/li><li>Contribute to the development of geological models and interpretations.<\/li><\/ul><\/li><li>Liaising with Drill Contractors and Other Geologists:<p><\/p><ul><li>Establish and maintain effective communication with drill contractors to ensure project objectives are met.<\/li><li>Collaborate with fellow geologists to share insights, coordinate activities, and enhance overall project understanding.<\/li><li>Provide clear and concise updates to project stakeholders, fostering a collaborative working environment.<\/li><\/ul><\/li><li>Geologic Mapping:<p><\/p><ul><li>Conduct geologic mapping to enhance the understanding of the project area.<\/li><li>Utilize mapping data to contribute to geological models and exploration strategies.<\/li><li>Document and communicate mapping findings to support broader geological interpretations.<\/li><\/ul><\/li><\/ol>\n<p>Qualifications:<\/p>\n<ul><li>Bachelor's or higher degree in Geology, Earth Sciences, or a related field.<\/li><li>Proven experience in drill core logging and sampling.<\/li><li>Proficiency in digital data entry and geological software.<\/li><li>Strong analytical and problem-solving skills.<\/li><li>Excellent communication and interpersonal skills.<\/li><li>Ability to work collaboratively in a team and independently in the field.<\/li><li>Familiarity with geologic mapping techniques and tools.<\/li><li>Must be authorized to work in the US without work visa sponsorship.<\/li><\/ul>","%category%":"","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/8336a8b8dcea-geologist","%breezy_id%":"8336a8b8dcea","%breezy_friendly_id%":"8336a8b8dcea-geologist","%breezy_created_date%":"2025-02-20T21:25:44.521Z","%breezy_updated_date%":"2025-02-20T21:26:23.961Z","%_wpgmp_location_city%":"Elko","%_wpgmp_location_state%":"NV","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Elko, NV, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"40.8436459","%_wpgmp_metabox_longitude%":"-115.7526187","%rank_math_internal_links_processed%":"1"}},"id":2194,"infowindow_disable":false},{"source":"post","title":"IT Service Desk Technician","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    IT Service Desk Technician\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Position Description: The successful candidate will be responsible for the configuration, installation, troubleshooting and repair of personal computers, printers, telephones,&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/it-service-desk-technician\/\" name=\"IT Service Desk Technician\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Position Description: The successful candidate will be responsible for the configuration, installation, troubleshooting and repair of personal computers, printers, telephones,&hellip;","address":"Winnemucca, NV, USA","location":{"lat":"40.9728274","city":"Winnemucca","state":"NV","country":"United States","lng":"-117.7357354","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/it-service-desk-technician\/","zoom":19,"extra_fields":{"post_excerpt":"Position Description: The successful candidate will be responsible for the configuration, installation, troubleshooting and repair of personal computers, printers, telephones,&hellip;","post_content":"<p><strong>Position Description:<\/strong><\/p>\n<p>The successful candidate will be responsible for the configuration, installation, troubleshooting and repair of personal computers, printers, telephones, mobile devices and data communications equipment; configuration and support of mobile devices; installation, configuration and support of desktop software systems; troubleshooting and resolving software and hardware problems; rotate through the role of on-call Help Desk technician on a periodic basis; perform other duties as assigned.<\/p>\n<p><strong>Key Responsibilities:<\/strong><\/p>\n<ul><li>Works at the Help Desk receives Help Desk tickets and telephone calls focusing on answering computer user requests for assistance, problem solving with a goal of first call resolution, providing troubleshooting and resolving of software, hardware, mobile and network problems.<\/li><li>Daily maintenance tasks, imaging computers and remediate broken clients<\/li><li>Assesses and collects essential issue data relative to problem and customer information for the dispatching a work to next tier support.<\/li><li>Provides first and second-level technical customer support; first level of support duties are receiving trouble calls via Help Desk tickets, telephone and e-mail and resolving issues within scope of role; if problems need a higher level support, the Help Desk technician will dispatch a service ticket to the appropriate higher level support personnel.<\/li><li>Provide local hands on support when higher level support needs physical assistance; second-level support is solving routine technical problems remotely from the Help Desk.<\/li><li>Responsible for day to day manning of the Help Desk ticketing system for all computer related trouble reported by local end users.<\/li><\/ul>\n<p><strong>Qualifications:<\/strong><\/p>\n<ul><li>Two (2) years of PC Technician experience in a business networking environment required<\/li><li>BS in Computer Sciences preferred<\/li><li>Microsoft MCSA or MCSE and A+ certifications preferred<\/li><li>Ability to lift and carry 50 pounds required<\/li><li>Ability to travel locally routinely required<\/li><li>Exceptional customer service\/interpersonal skills required<\/li><li>Demonstrated extensive knowledge of personal computers in a networked environment including data and telecommunications equipment required<\/li><li>Knowledge of and experience with, local area networks and associated protocols and equipment. Specifically, Microsoft Windows, IOS environments, mobile devices, firewall technology and TCP\/IP. Familiarity of Cisco networking equipment preferred<\/li><\/ul>\n<p><strong>What we can Offer You<\/strong><\/p>\n<ul><li>A comprehensive compensation package including benefits<\/li><li>Ability to make a difference and lasting impact<\/li><li>Work in a dynamic, collaborative, progressive, and high-performing team<\/li><li>An Opportunity to transform Traditional Mining into the future of Digital Mining<\/li><li>Opportunities to grow and learn with industry colleagues are endless<\/li><li>Must be authorized to work in the US without work visa sponsorship<\/li><\/ul>","post_title":"IT Service Desk Technician","post_link":"https:\/\/turnerstaffing.com\/position\/it-service-desk-technician\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"","%location_country%":"United States","%location_city%":"Winnemucca","%location_state_id%":"NV","%location_state_name%":"Nevada","%location_city_state%":"Winnemucca, NV","%education%":"","%department%":"","%description%":"<p><strong>Position Description:<\/strong><\/p>\n<p>The successful candidate will be responsible for the configuration, installation, troubleshooting and repair of personal computers, printers, telephones, mobile devices and data communications equipment; configuration and support of mobile devices; installation, configuration and support of desktop software systems; troubleshooting and resolving software and hardware problems; rotate through the role of on-call Help Desk technician on a periodic basis; perform other duties as assigned.<\/p>\n<p><strong>Key Responsibilities:<\/strong><\/p>\n<ul><li>Works at the Help Desk receives Help Desk tickets and telephone calls focusing on answering computer user requests for assistance, problem solving with a goal of first call resolution, providing troubleshooting and resolving of software, hardware, mobile and network problems.<\/li><li>Daily maintenance tasks, imaging computers and remediate broken clients<\/li><li>Assesses and collects essential issue data relative to problem and customer information for the dispatching a work to next tier support.<\/li><li>Provides first and second-level technical customer support; first level of support duties are receiving trouble calls via Help Desk tickets, telephone and e-mail and resolving issues within scope of role; if problems need a higher level support, the Help Desk technician will dispatch a service ticket to the appropriate higher level support personnel.<\/li><li>Provide local hands on support when higher level support needs physical assistance; second-level support is solving routine technical problems remotely from the Help Desk.<\/li><li>Responsible for day to day manning of the Help Desk ticketing system for all computer related trouble reported by local end users.<\/li><\/ul>\n<p><strong>Qualifications:<\/strong><\/p>\n<ul><li>Two (2) years of PC Technician experience in a business networking environment required<\/li><li>BS in Computer Sciences preferred<\/li><li>Microsoft MCSA or MCSE and A+ certifications preferred<\/li><li>Ability to lift and carry 50 pounds required<\/li><li>Ability to travel locally routinely required<\/li><li>Exceptional customer service\/interpersonal skills required<\/li><li>Demonstrated extensive knowledge of personal computers in a networked environment including data and telecommunications equipment required<\/li><li>Knowledge of and experience with, local area networks and associated protocols and equipment. Specifically, Microsoft Windows, IOS environments, mobile devices, firewall technology and TCP\/IP. Familiarity of Cisco networking equipment preferred<\/li><\/ul>\n<p><strong>What we can Offer You<\/strong><\/p>\n<ul><li>A comprehensive compensation package including benefits<\/li><li>Ability to make a difference and lasting impact<\/li><li>Work in a dynamic, collaborative, progressive, and high-performing team<\/li><li>An Opportunity to transform Traditional Mining into the future of Digital Mining<\/li><li>Opportunities to grow and learn with industry colleagues are endless<\/li><li>Must be authorized to work in the US without work visa sponsorship<\/li><\/ul>","%category%":"","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/4327cfd8b3d3-it-service-desk-technician","%breezy_id%":"4327cfd8b3d3","%breezy_friendly_id%":"4327cfd8b3d3-it-service-desk-technician","%breezy_created_date%":"2025-02-20T15:44:45.652Z","%breezy_updated_date%":"2025-02-20T15:45:11.691Z","%_wpgmp_location_city%":"Winnemucca","%_wpgmp_location_state%":"NV","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Winnemucca, NV, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"40.9728274","%_wpgmp_metabox_longitude%":"-117.7357354","%rank_math_internal_links_processed%":"1"}},"id":2191,"infowindow_disable":false},{"source":"post","title":"Heavy Equipment Operator","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Heavy Equipment Operator\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Turner Mining Group \u2013 Heavy Equipment Operator Do you love mining? Do you think differently? Are you ready to define&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/heavy-equipment-operator-2\/\" name=\"Heavy Equipment Operator\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Turner Mining Group \u2013 Heavy Equipment Operator Do you love mining? Do you think differently? Are you ready to define&hellip;","address":"Kermit, TX, USA","location":{"lat":"31.8576265","city":"Kermit","state":"TX","country":"United States","lng":"-103.0926652","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/heavy-equipment-operator-2\/","zoom":19,"extra_fields":{"post_excerpt":"Turner Mining Group \u2013 Heavy Equipment Operator Do you love mining? Do you think differently? Are you ready to define&hellip;","post_content":"<p><strong><u>Turner Mining Group \u2013 Heavy Equipment Operator<\/u><\/strong><\/p>\n<p>Do you love mining? Do you think differently? Are you ready to define the future of this industry?<\/p>\n<p>We\u2019ve been waiting for you! Turner Mining Group is committed to changing the way mining companies do business. We develop our people. We partner with our clients. We believe in win, win, win.<\/p>\n<p>We are looking for a dynamic and talented mining Heavy Equipment Operators for our fast-growing, forward thinking mining services company headquartered in Bloomington, Indiana with our Operations team headquartered in Salt Lake City, Utah.<\/p>\n<p>Turner Mining Group is seeking an energetic mining professionals who can leverage their mining knowledge to expand upon our fast-growing business, creating best practices for equipment operations to ensure profitable operations.<\/p>\n<p><strong>You<\/strong><\/p>\n<p>You want to work for a services company that is rapidly changing the way the largest materials producers do business. You are motivated by solving problems and partnering with our clients and suppliers. You want to work with great people and enjoy being a part of a strong team. You are a knowledgeable Operator who is not afraid to jump into every detail. You want to be in a place where continuous learning and growth is the norm. You are adaptable and able to juggle multiple initiatives concurrently.<\/p>\n<p><strong>Responsibilities:<\/strong><\/p>\n<ul><li>Operating heavy equipment including loaders, scrapers, blade, excavators, dozers, haul trucks, and other pieces of heavy equipment in a production environment<\/li><li>Performing all pre-shift inspections, some basic maintenance and upkeep<\/li><li>Working with teammates on crew to maximize production while always maintaining our safety rules and regulations.<\/li><\/ul>\n<p><strong>Requirements:<\/strong><\/p>\n<ul><li>Safety oriented, awareness of everyone and everything that is around you<\/li><li>Strong work ethic<\/li><li>Willingness to learn<\/li><li>Ability to be flexible and to adapt<\/li><li>Experience with heavy equipment<\/li><li>Preferred to have MSHA training<\/li><\/ul>\n<p><strong>Benefits:<\/strong><\/p>\n<p>Turner Mining Group offers a competitive salary, an excellent work culture, career advancement opportunities. Our team offers a benefits program which includes Medical, Dental, Vision, Life, and a 401k with company match.<\/p>\n<p>At Turner Mining Group, we encourage and celebrate an inclusive environment for all employees and are proud to be an equal opportunity workplace and affirmative action employer.<\/p>","post_title":"Heavy Equipment Operator","post_link":"https:\/\/turnerstaffing.com\/position\/heavy-equipment-operator-2\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Associate","%location_country%":"United States","%location_city%":"Kermit","%location_state_id%":"TX","%location_state_name%":"Texas","%location_city_state%":"Kermit, TX","%education%":"Unspecified","%department%":"Operations","%description%":"<p><strong><u>Turner Mining Group \u2013 Heavy Equipment Operator<\/u><\/strong><\/p>\n<p>Do you love mining? Do you think differently? Are you ready to define the future of this industry?<\/p>\n<p>We\u2019ve been waiting for you! Turner Mining Group is committed to changing the way mining companies do business. We develop our people. We partner with our clients. We believe in win, win, win.<\/p>\n<p>We are looking for a dynamic and talented mining Heavy Equipment Operators for our fast-growing, forward thinking mining services company headquartered in Bloomington, Indiana with our Operations team headquartered in Salt Lake City, Utah.<\/p>\n<p>Turner Mining Group is seeking an energetic mining professionals who can leverage their mining knowledge to expand upon our fast-growing business, creating best practices for equipment operations to ensure profitable operations.<\/p>\n<p><strong>You<\/strong><\/p>\n<p>You want to work for a services company that is rapidly changing the way the largest materials producers do business. You are motivated by solving problems and partnering with our clients and suppliers. You want to work with great people and enjoy being a part of a strong team. You are a knowledgeable Operator who is not afraid to jump into every detail. You want to be in a place where continuous learning and growth is the norm. You are adaptable and able to juggle multiple initiatives concurrently.<\/p>\n<p><strong>Responsibilities:<\/strong><\/p>\n<ul><li>Operating heavy equipment including loaders, scrapers, blade, excavators, dozers, haul trucks, and other pieces of heavy equipment in a production environment<\/li><li>Performing all pre-shift inspections, some basic maintenance and upkeep<\/li><li>Working with teammates on crew to maximize production while always maintaining our safety rules and regulations.<\/li><\/ul>\n<p><strong>Requirements:<\/strong><\/p>\n<ul><li>Safety oriented, awareness of everyone and everything that is around you<\/li><li>Strong work ethic<\/li><li>Willingness to learn<\/li><li>Ability to be flexible and to adapt<\/li><li>Experience with heavy equipment<\/li><li>Preferred to have MSHA training<\/li><\/ul>\n<p><strong>Benefits:<\/strong><\/p>\n<p>Turner Mining Group offers a competitive salary, an excellent work culture, career advancement opportunities. Our team offers a benefits program which includes Medical, Dental, Vision, Life, and a 401k with company match.<\/p>\n<p>At Turner Mining Group, we encourage and celebrate an inclusive environment for all employees and are proud to be an equal opportunity workplace and affirmative action employer.<\/p>","%category%":"Operations","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/ecaf701607b9-heavy-equipment-operator","%breezy_id%":"ecaf701607b9","%breezy_friendly_id%":"ecaf701607b9-heavy-equipment-operator","%breezy_created_date%":"2025-02-18T16:55:09.580Z","%breezy_updated_date%":"2025-03-06T19:45:24.275Z","%_wpgmp_location_city%":"Kermit","%_wpgmp_location_state%":"TX","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Kermit, TX, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"31.8576265","%_wpgmp_metabox_longitude%":"-103.0926652","%rank_math_internal_links_processed%":"1"}},"id":2181,"infowindow_disable":false},{"source":"post","title":"CNC Machinist","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    CNC Machinist\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Position Overview The CNC Machinist will set up and operate conventional, special purpose, CNC, and Numerical Control (NC) machines and&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/cnc-machinist\/\" name=\"CNC Machinist\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Position Overview The CNC Machinist will set up and operate conventional, special purpose, CNC, and Numerical Control (NC) machines and&hellip;","address":"Phoenix, AZ, USA","location":{"lat":"33.4482266","city":"Phoenix","state":"AZ","country":"United States","lng":"-112.0776781","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/cnc-machinist\/","zoom":19,"extra_fields":{"post_excerpt":"Position Overview The CNC Machinist will set up and operate conventional, special purpose, CNC, and Numerical Control (NC) machines and&hellip;","post_content":"<h1>Position Overview<\/h1>\n<p>The CNC Machinist will set up and operate conventional, special purpose, CNC, and Numerical Control (NC) machines and machining centers to fabricate metallic and nonmetallic parts by performing the essential functions listed below. <\/p>\n<ul><li>This is a non-exempt, hourly position. <\/li><li>Pay commensurate with experience ($30-$50\/hr.).<\/li><li>The CNC machinist will work 10 days on 4 days off schedule, 6:00 am to 5:00 pm.<\/li><\/ul>\n<h1>Essential Functions<\/h1>\n<ul><li>Demonstrate a strong commitment to safe work practices and procedures.<\/li><li><strong>\u00b7        <\/strong>Studies blueprints, sketches, drawings, manuals, specifications, or sample parts to determine dimensions and tolerances of finished workpieces, sequence of operations, and setup requirements. <\/li><li><strong>\u00b7        <\/strong>Measures, marks, and scribes dimensions and reference points on material or workpiece as guides for subsequent machining as necessary. <\/li><li><strong>\u00b7        <\/strong>Selects, aligns, and secures holding fixtures, cutting tools, attachments, accessories, and materials on machines as necessary to machine parts as required.&nbsp; <\/li><li><strong>\u00b7        <\/strong>Calculates and sets controls to regulate machining factors such as speed, feed, coolant flow, and depth and angle of cut, or enters commands to retrieve, input, or edit computerized machine control media according to established guidelines and procedures.&nbsp; <\/li><li><strong>\u00b7        <\/strong>Starts and observes machine operation to detect malfunctions or out-of-tolerance machining and adjusts machine controls or control media as required.&nbsp; <\/li><li><strong>\u00b7        <\/strong>Verifies conformance of finished workpiece to specifications, using measuring and inspection tools as necessary.&nbsp; <\/li><li><strong>\u00b7        <\/strong>Set up and operate the machine on a trial run to verify the accuracy of machine settings or programmed control data.&nbsp; <\/li><li><strong>\u00b7        <\/strong>Performs routine maintenance tasks on machines as required.&nbsp; <\/li><li><strong>\u00b7        <\/strong>Confers with engineers, production personnel, programmers, or others to resolve machining or assembly problems.<\/li><li>Maintain a clean and organized work area and maintain all equipment, to like new appearance, according to maintenance plans and established procedures.<\/li><li>Maintain a positive work atmosphere by acting and communicating in a manner so that you get along with customers, clients, coworkers, and management.<\/li><\/ul>\n<h1>Qualifications<\/h1>\n<ul><li>Associate\u2019s degree (A. A.) from a two-year college or technical school; or two to three years related experience and\/or training; or equivalent combination of education and experience.<\/li><li>Ability to read technical drawings.<\/li><li>Ability to read and interpret documents such as safety rules, operating and maintenance instructions, and procedure manuals.&nbsp; <\/li><li>Ability to write routine reports and correspondence.<\/li><li>Ability to work with mathematical concepts such as portability and statistical inference and fundamentals of plane and solid geometry and trigonometry.&nbsp; <\/li><li>Ability to apply concepts such as fractions, percentages, ratios, and proportions to practical situations.<\/li><li>Ability to solve practical problems and deal with a variety of concrete variables in situations where only limited standardization exists.<\/li><li>Ability to interpret a variety of instructions furnished in written, oral, diagram, or schedule form.<\/li><li>Mazak Mazatrol programming experience preferred. <\/li><li>Must pass a pre-employment physical, drug (including the use of marijuana) and alcohol screening, Motor Vehicle Report (MVR), and additional background screening as required by regulation and\/or industry practice. <\/li><li>Must have a valid driver's license. <\/li><\/ul>","post_title":"CNC Machinist","post_link":"https:\/\/turnerstaffing.com\/position\/cnc-machinist\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Mid Level","%location_country%":"United States","%location_city%":"Phoenix","%location_state_id%":"AZ","%location_state_name%":"Arizona","%location_city_state%":"Phoenix, AZ","%education%":"Unspecified","%department%":"","%description%":"<h1>Position Overview<\/h1>\n<p>The CNC Machinist will set up and operate conventional, special purpose, CNC, and Numerical Control (NC) machines and machining centers to fabricate metallic and nonmetallic parts by performing the essential functions listed below. <\/p>\n<ul><li>This is a non-exempt, hourly position. <\/li><li>Pay commensurate with experience ($30-$50\/hr.).<\/li><li>The CNC machinist will work 10 days on 4 days off schedule, 6:00 am to 5:00 pm.<\/li><\/ul>\n<h1>Essential Functions<\/h1>\n<ul><li>Demonstrate a strong commitment to safe work practices and procedures.<\/li><li><strong>\u00b7        <\/strong>Studies blueprints, sketches, drawings, manuals, specifications, or sample parts to determine dimensions and tolerances of finished workpieces, sequence of operations, and setup requirements. <\/li><li><strong>\u00b7        <\/strong>Measures, marks, and scribes dimensions and reference points on material or workpiece as guides for subsequent machining as necessary. <\/li><li><strong>\u00b7        <\/strong>Selects, aligns, and secures holding fixtures, cutting tools, attachments, accessories, and materials on machines as necessary to machine parts as required.&nbsp; <\/li><li><strong>\u00b7        <\/strong>Calculates and sets controls to regulate machining factors such as speed, feed, coolant flow, and depth and angle of cut, or enters commands to retrieve, input, or edit computerized machine control media according to established guidelines and procedures.&nbsp; <\/li><li><strong>\u00b7        <\/strong>Starts and observes machine operation to detect malfunctions or out-of-tolerance machining and adjusts machine controls or control media as required.&nbsp; <\/li><li><strong>\u00b7        <\/strong>Verifies conformance of finished workpiece to specifications, using measuring and inspection tools as necessary.&nbsp; <\/li><li><strong>\u00b7        <\/strong>Set up and operate the machine on a trial run to verify the accuracy of machine settings or programmed control data.&nbsp; <\/li><li><strong>\u00b7        <\/strong>Performs routine maintenance tasks on machines as required.&nbsp; <\/li><li><strong>\u00b7        <\/strong>Confers with engineers, production personnel, programmers, or others to resolve machining or assembly problems.<\/li><li>Maintain a clean and organized work area and maintain all equipment, to like new appearance, according to maintenance plans and established procedures.<\/li><li>Maintain a positive work atmosphere by acting and communicating in a manner so that you get along with customers, clients, coworkers, and management.<\/li><\/ul>\n<h1>Qualifications<\/h1>\n<ul><li>Associate\u2019s degree (A. A.) from a two-year college or technical school; or two to three years related experience and\/or training; or equivalent combination of education and experience.<\/li><li>Ability to read technical drawings.<\/li><li>Ability to read and interpret documents such as safety rules, operating and maintenance instructions, and procedure manuals.&nbsp; <\/li><li>Ability to write routine reports and correspondence.<\/li><li>Ability to work with mathematical concepts such as portability and statistical inference and fundamentals of plane and solid geometry and trigonometry.&nbsp; <\/li><li>Ability to apply concepts such as fractions, percentages, ratios, and proportions to practical situations.<\/li><li>Ability to solve practical problems and deal with a variety of concrete variables in situations where only limited standardization exists.<\/li><li>Ability to interpret a variety of instructions furnished in written, oral, diagram, or schedule form.<\/li><li>Mazak Mazatrol programming experience preferred. <\/li><li>Must pass a pre-employment physical, drug (including the use of marijuana) and alcohol screening, Motor Vehicle Report (MVR), and additional background screening as required by regulation and\/or industry practice. <\/li><li>Must have a valid driver's license. <\/li><\/ul>","%category%":"Operations","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/08d567f783a5-cnc-machinist","%breezy_id%":"08d567f783a5","%breezy_friendly_id%":"08d567f783a5-cnc-machinist","%breezy_created_date%":"2025-02-18T17:59:49.317Z","%breezy_updated_date%":"2025-02-20T15:58:14.814Z","%_wpgmp_location_city%":"Phoenix","%_wpgmp_location_state%":"AZ","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Phoenix, AZ, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"33.4482266","%_wpgmp_metabox_longitude%":"-112.0776781","%rank_math_internal_links_processed%":"1"}},"id":2182,"infowindow_disable":false},{"source":"post","title":"Senior Project Manager- Commercial Construction","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Senior Project Manager- Commercial Construction\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    JOB DESCRIPTION: SENIOR PROJECT MANAGER Reports to: &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Operations Manager&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; Position Mission:&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Execute projects in line with company mission and core values&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/senior-project-manager-commercial-construction\/\" name=\"Senior Project Manager- Commercial Construction\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"JOB DESCRIPTION: SENIOR PROJECT MANAGER Reports to: &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Operations Manager&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; Position Mission:&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Execute projects in line with company mission and core values&hellip;","address":"Orange Beach, AL, USA","location":{"lat":"30.2697033","city":"Orange Beach","state":"AL","country":"United States","lng":"-87.5867598","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/senior-project-manager-commercial-construction\/","zoom":19,"extra_fields":{"post_excerpt":"JOB DESCRIPTION: SENIOR PROJECT MANAGER Reports to: &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Operations Manager&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; Position Mission:&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Execute projects in line with company mission and core values&hellip;","post_content":"<p><strong>JOB DESCRIPTION: SENIOR PROJECT MANAGER<\/strong><\/p>\n<p><\/p>\n<p><strong>Reports to:<\/strong>        &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Operations Manager&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<\/p>\n<p><\/p>\n<p><strong>Position Mission:<\/strong>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Execute projects in line with company mission and core values while developing team.<\/p>\n<p><\/p>\n<p><strong>Results\/Measurables:<\/strong><\/p>\n<p>1)&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Lead, manage, and holding accountable team.<\/p>\n<p>2)&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Team Performance<\/p>\n<p>3)&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Project Execution<\/p>\n<p>4)&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Customer Satisfaction<\/p>\n<p>5)&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Project Financial Results<\/p>\n<p><\/p>\n<p><strong>Role Competencies:<\/strong><\/p>\n<p>1)&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Strategic thinking\/visioning \u2013 Able to see and communicate the big picture in an inspiring way.&nbsp;Determines opportunities and threats through comprehensive analysis of current and future trends.<\/p>\n<p>2)&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Ability to develop people&nbsp;\u2013 Coaches people in their current roles to improve performance and prepares them for future roles.<\/p>\n<p>3)&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Proactivity \u2013 Acts without being told what to do.&nbsp;Brings new ideas to the company.<\/p>\n<p>4)&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;High standards \u2013 Expects personal performance and team performance to be nothing short of the best.<\/p>\n<p>5)&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Process oriented \u2013 Focuses on establishing, following, and improving company processes.<\/p>\n<p>6)&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Organization &amp; planning \u2013 Plans, organizes, schedules, and budgets in an efficient, productive manner.&nbsp;Focuses on key priorities.<\/p>\n<p><\/p>\n<p><strong>Culture Competencies:<\/strong><\/p>\n<p>1)&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<u>Relationships<\/u>&nbsp;\u2013 Focuses on long lasting value rather than short term gain. Straightforward communication in the best interest of others over what is comfortable.<\/p>\n<p>2)&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<u>Effort<\/u>&nbsp;\u2013 Possesses a strong willingness to work hard and sometimes long hours to get the job done.&nbsp;Has a track record of working hard.&nbsp;Challenges oneself for the team\u2019s success.<\/p>\n<p>3)&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<u>Servant Hearted&nbsp;<\/u>\u2013 Humble. Interested in the ideas of others. Team oriented. Putting others before yourself. Grateful.<\/p>\n<p>4)&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<u>Trustworthy<\/u>&nbsp;\u2013 Can be relied upon.&nbsp;Seeks truth and fairness.&nbsp;Does not cut corners.&nbsp;Does what is right.&nbsp;Speaks plainly and truthfully.<\/p>\n<p>5)&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<u>Ownership<\/u>&nbsp;\u2013 Accountable.&nbsp;Never looking to shift blame.&nbsp;Takes responsibility.&nbsp;Unwavering commitment.&nbsp;Focuses on solutions rather than problems.<\/p>\n<p>6)&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<u>Results<\/u>&nbsp;\u2013 Stands by facts not theories.&nbsp;Keenly interested in the outcome.&nbsp;Uses past results to improve future outcomes.<\/p>\n<p>7)&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<u>Excellence<\/u>&nbsp;\u2013 Desires to perform at a high level and to improve processes.&nbsp;Committed to personal and professional growth.<\/p>\n<p><\/p>\n<p><strong>Job Responsibilities Include:<\/strong><\/p>\n<p>1.&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Lead, manage, and hold direct reports accountable (LMA)<\/p>\n<p>2.&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Build excellent relationships with clients, subs, vendors, and CSC team members<\/p>\n<p>3.&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Execute projects focusing on safety, quality, schedule, and profitability<\/p>\n<p>4.&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Develop project team members for future growth (includes recruiting, hiring, and leading Superintendents, Interns, APM\u2019s, PM\u2019s)<\/p>\n<p>5.&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Manage assigned projects directly<\/p>","post_title":"Senior Project Manager- Commercial Construction","post_link":"https:\/\/turnerstaffing.com\/position\/senior-project-manager-commercial-construction\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Senior","%location_country%":"United States","%location_city%":"Orange Beach","%location_state_id%":"AL","%location_state_name%":"Alabama","%location_city_state%":"Orange Beach, AL","%education%":"Unspecified","%department%":"","%description%":"<p><strong>JOB DESCRIPTION: SENIOR PROJECT MANAGER<\/strong><\/p>\n<p><\/p>\n<p><strong>Reports to:<\/strong>        &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Operations Manager&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<\/p>\n<p><\/p>\n<p><strong>Position Mission:<\/strong>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Execute projects in line with company mission and core values while developing team.<\/p>\n<p><\/p>\n<p><strong>Results\/Measurables:<\/strong><\/p>\n<p>1)&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Lead, manage, and holding accountable team.<\/p>\n<p>2)&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Team Performance<\/p>\n<p>3)&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Project Execution<\/p>\n<p>4)&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Customer Satisfaction<\/p>\n<p>5)&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Project Financial Results<\/p>\n<p><\/p>\n<p><strong>Role Competencies:<\/strong><\/p>\n<p>1)&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Strategic thinking\/visioning \u2013 Able to see and communicate the big picture in an inspiring way.&nbsp;Determines opportunities and threats through comprehensive analysis of current and future trends.<\/p>\n<p>2)&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Ability to develop people&nbsp;\u2013 Coaches people in their current roles to improve performance and prepares them for future roles.<\/p>\n<p>3)&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Proactivity \u2013 Acts without being told what to do.&nbsp;Brings new ideas to the company.<\/p>\n<p>4)&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;High standards \u2013 Expects personal performance and team performance to be nothing short of the best.<\/p>\n<p>5)&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Process oriented \u2013 Focuses on establishing, following, and improving company processes.<\/p>\n<p>6)&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Organization &amp; planning \u2013 Plans, organizes, schedules, and budgets in an efficient, productive manner.&nbsp;Focuses on key priorities.<\/p>\n<p><\/p>\n<p><strong>Culture Competencies:<\/strong><\/p>\n<p>1)&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<u>Relationships<\/u>&nbsp;\u2013 Focuses on long lasting value rather than short term gain. Straightforward communication in the best interest of others over what is comfortable.<\/p>\n<p>2)&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<u>Effort<\/u>&nbsp;\u2013 Possesses a strong willingness to work hard and sometimes long hours to get the job done.&nbsp;Has a track record of working hard.&nbsp;Challenges oneself for the team\u2019s success.<\/p>\n<p>3)&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<u>Servant Hearted&nbsp;<\/u>\u2013 Humble. Interested in the ideas of others. Team oriented. Putting others before yourself. Grateful.<\/p>\n<p>4)&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<u>Trustworthy<\/u>&nbsp;\u2013 Can be relied upon.&nbsp;Seeks truth and fairness.&nbsp;Does not cut corners.&nbsp;Does what is right.&nbsp;Speaks plainly and truthfully.<\/p>\n<p>5)&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<u>Ownership<\/u>&nbsp;\u2013 Accountable.&nbsp;Never looking to shift blame.&nbsp;Takes responsibility.&nbsp;Unwavering commitment.&nbsp;Focuses on solutions rather than problems.<\/p>\n<p>6)&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<u>Results<\/u>&nbsp;\u2013 Stands by facts not theories.&nbsp;Keenly interested in the outcome.&nbsp;Uses past results to improve future outcomes.<\/p>\n<p>7)&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<u>Excellence<\/u>&nbsp;\u2013 Desires to perform at a high level and to improve processes.&nbsp;Committed to personal and professional growth.<\/p>\n<p><\/p>\n<p><strong>Job Responsibilities Include:<\/strong><\/p>\n<p>1.&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Lead, manage, and hold direct reports accountable (LMA)<\/p>\n<p>2.&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Build excellent relationships with clients, subs, vendors, and CSC team members<\/p>\n<p>3.&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Execute projects focusing on safety, quality, schedule, and profitability<\/p>\n<p>4.&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Develop project team members for future growth (includes recruiting, hiring, and leading Superintendents, Interns, APM\u2019s, PM\u2019s)<\/p>\n<p>5.&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Manage assigned projects directly<\/p>","%category%":"Management","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/e07bf08b9762-senior-project-manager-commercial-construction","%breezy_id%":"e07bf08b9762","%breezy_friendly_id%":"e07bf08b9762-senior-project-manager-commercial-construction","%breezy_created_date%":"2025-02-17T20:01:38.768Z","%breezy_updated_date%":"2025-02-17T20:03:12.285Z","%_wpgmp_location_city%":"Orange Beach","%_wpgmp_location_state%":"AL","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Orange Beach, AL, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"30.2697033","%_wpgmp_metabox_longitude%":"-87.5867598","%rank_math_internal_links_processed%":"1"}},"id":2166,"infowindow_disable":false},{"source":"post","title":"Project Engineer","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Project Engineer\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Project Engineer Advisor to Project Management Reports to Project Manager Reporting to the Project Manager, the Project Engineer plays a&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/project-engineer\/\" name=\"Project Engineer\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Project Engineer Advisor to Project Management Reports to Project Manager Reporting to the Project Manager, the Project Engineer plays a&hellip;","address":"Kingman, AZ, USA","location":{"lat":"35.1912977","city":"Kingman","state":"AZ","country":"United States","lng":"-114.0522845","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/project-engineer\/","zoom":19,"extra_fields":{"post_excerpt":"Project Engineer Advisor to Project Management Reports to Project Manager Reporting to the Project Manager, the Project Engineer plays a&hellip;","post_content":"<p><strong><u>Project Engineer<\/u><\/strong><\/p>\n<p><strong>Advisor to Project Management<\/strong><\/p>\n<p><strong>Reports to Project Manager<\/strong><\/p>\n<p>Reporting to the Project Manager, the Project Engineer plays a crucial role in bridging technical mining expertise with mining operations by providing insights through engineering guidance, driving operational efficiency, financial accountability, and long-term project success. This position is responsible for analyzing operational data, preparing engineering designs\/operational GPS support, conducting field data collection, and production forecasting.<\/p>\n<p>By integrating engineering principles, the role provides support for optimizing mining operations, identifying cost-saving opportunities, and evaluating potential efficiency improvements. Additionally, it involves collaboration with Turner Mining Group and client teams, ensuring alignment between corporate objectives, site-level execution, and regulatory compliance.<\/p>\n<p>This role requires a strong operational mindset, familiar with MSHA safety guidelines, industry knowledge, and the ability to analyze complex data into actionable recommendations. With a focus on continuous improvement, efficiency, and project execution, the Project Engineer is integral to enhancing both operational performance and efficiency at Turner Mining Group.<\/p>\n<p><strong><u>Position Responsibilities:<\/u><\/strong><\/p>\n<p><strong>Operational &amp; Technical Analysis<\/strong><\/p>\n<p>\u2022 Review operational reports (cost, safety, production) and analyze data for key trends.<\/p>\n<p>\u2022 Develop and implement continuous improvement initiatives to enhance efficiency and reduce costs.<\/p>\n<p>\u2022 Conduct risk assessments for operational, technical, and financial aspects of mining projects.<\/p>\n<p>\u2022 Collaborate with engineering and operations teams to optimize mine planning, design, and extraction techniques.<\/p>\n<p>\u2022 Develop and track key performance indicators (KPIs) to monitor operational performance and drive improvements.<\/p>\n<p><strong>Mine Engineering &amp; Survey Duties<\/strong><\/p>\n<p>\u2022 Manage fleet management and high precision GPS systems.<\/p>\n<p>\u2022 Develop Drill &amp; Blast pattern, profile, and timing designs and short-range plans.<\/p>\n<p>\u2022 Produce road designs, stockpile and waste storage designs, and others in Hexagon MineSight.<\/p>\n<p>\u2022 Operate survey drones and reconcile results.<\/p>\n<p>\u2022 Analyze FMS and other data for risks and opportunities.<\/p>\n<p>\u2022 Audit and advise client on short range mine plans.<\/p>\n<p><strong>Client &amp; Cross-Functional Collaboration<\/strong><\/p>\n<p>\u2022 Work closely with Turner Mining departments and external stakeholders to define project scopes and execution strategies.<\/p>\n<p>\u2022 Act as a technical link between client technical services and project management to ensure alignment on operational objectives.<\/p>\n<p>\u2022 Participate in knowledge-sharing initiatives, such as internal workshops and training, to support operational and analytical capabilities across teams.<\/p>\n<p>\u2022 Engage with suppliers and service providers to optimize procurement strategies for project operations.<\/p>\n<p><strong>Compliance and Safety Integration<\/strong><\/p>\n<p>\u2022 Ensure that all engineering recommendations align with MSHA safety regulations and industry best practices.<\/p>\n<p>\u2022 Develop and maintain standard operating procedures (SOPs) for operational and safety processes.<\/p>\n<p>\u2022 Provide technical guidance to ensure site compliance with environmental and regulatory requirements.<\/p>\n<p><strong><u>Other duties as required.<\/u><\/strong><\/p>\n<p><strong>The Ideal Candidate:<\/strong><\/p>\n<p><strong>Education and Experience<\/strong><\/p>\n<p>\u2022 Mining or Civil Engineering Degree or related.<\/p>\n<p>\u2022 3 years of mine site engineering or operational experience.<\/p>\n<p>\u2022 Hands-on experience with mining engineering software (Hexagon MineSight preferred or similar).<\/p>\n<p>\u2022 Strong proficiency in MS Office (Word, Excel, PowerPoint, Outlook).<\/p>\n<p>\u2022 Part 107 drone license preferred<\/p>\n<p>\u2022 Procurement and mine accounting experience preferred<\/p>\n<p><strong>Technical and Analytical Skills<\/strong><\/p>\n<p>\u2022 Strong problem-solving and data analysis capabilities.<\/p>\n<p>\u2022 Ability to translate complex engineering data into actionable recommendations.<\/p>\n<p>\u2022 Knowledge of drill &amp; blast design, mine haulage analysis, and GPS fleet management.<\/p>\n<p>\u2022 Familiarity with mine accounting and procurement processes (preferred but not required).<\/p>\n<p><strong>Key Competencies \/ Skills<\/strong><\/p>\n<p>\u2022 Results-oriented with a proactive, problem-solving mindset.<\/p>\n<p>\u2022 Effective communicator, capable of working with cross-functional teams and clients.<\/p>\n<p>\u2022 Ability to work independently and manage multiple priorities in a dynamic environment.<\/p>\n<p>\u2022 Detail-oriented with strong documentation and technical writing skills.<\/p>","post_title":"Project Engineer","post_link":"https:\/\/turnerstaffing.com\/position\/project-engineer\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Associate","%location_country%":"United States","%location_city%":"Kingman","%location_state_id%":"AZ","%location_state_name%":"Arizona","%location_city_state%":"Kingman, AZ","%education%":"Bachelor's Degree","%department%":"Engineering","%description%":"<p><strong><u>Project Engineer<\/u><\/strong><\/p>\n<p><strong>Advisor to Project Management<\/strong><\/p>\n<p><strong>Reports to Project Manager<\/strong><\/p>\n<p>Reporting to the Project Manager, the Project Engineer plays a crucial role in bridging technical mining expertise with mining operations by providing insights through engineering guidance, driving operational efficiency, financial accountability, and long-term project success. This position is responsible for analyzing operational data, preparing engineering designs\/operational GPS support, conducting field data collection, and production forecasting.<\/p>\n<p>By integrating engineering principles, the role provides support for optimizing mining operations, identifying cost-saving opportunities, and evaluating potential efficiency improvements. Additionally, it involves collaboration with Turner Mining Group and client teams, ensuring alignment between corporate objectives, site-level execution, and regulatory compliance.<\/p>\n<p>This role requires a strong operational mindset, familiar with MSHA safety guidelines, industry knowledge, and the ability to analyze complex data into actionable recommendations. With a focus on continuous improvement, efficiency, and project execution, the Project Engineer is integral to enhancing both operational performance and efficiency at Turner Mining Group.<\/p>\n<p><strong><u>Position Responsibilities:<\/u><\/strong><\/p>\n<p><strong>Operational &amp; Technical Analysis<\/strong><\/p>\n<p>\u2022 Review operational reports (cost, safety, production) and analyze data for key trends.<\/p>\n<p>\u2022 Develop and implement continuous improvement initiatives to enhance efficiency and reduce costs.<\/p>\n<p>\u2022 Conduct risk assessments for operational, technical, and financial aspects of mining projects.<\/p>\n<p>\u2022 Collaborate with engineering and operations teams to optimize mine planning, design, and extraction techniques.<\/p>\n<p>\u2022 Develop and track key performance indicators (KPIs) to monitor operational performance and drive improvements.<\/p>\n<p><strong>Mine Engineering &amp; Survey Duties<\/strong><\/p>\n<p>\u2022 Manage fleet management and high precision GPS systems.<\/p>\n<p>\u2022 Develop Drill &amp; Blast pattern, profile, and timing designs and short-range plans.<\/p>\n<p>\u2022 Produce road designs, stockpile and waste storage designs, and others in Hexagon MineSight.<\/p>\n<p>\u2022 Operate survey drones and reconcile results.<\/p>\n<p>\u2022 Analyze FMS and other data for risks and opportunities.<\/p>\n<p>\u2022 Audit and advise client on short range mine plans.<\/p>\n<p><strong>Client &amp; Cross-Functional Collaboration<\/strong><\/p>\n<p>\u2022 Work closely with Turner Mining departments and external stakeholders to define project scopes and execution strategies.<\/p>\n<p>\u2022 Act as a technical link between client technical services and project management to ensure alignment on operational objectives.<\/p>\n<p>\u2022 Participate in knowledge-sharing initiatives, such as internal workshops and training, to support operational and analytical capabilities across teams.<\/p>\n<p>\u2022 Engage with suppliers and service providers to optimize procurement strategies for project operations.<\/p>\n<p><strong>Compliance and Safety Integration<\/strong><\/p>\n<p>\u2022 Ensure that all engineering recommendations align with MSHA safety regulations and industry best practices.<\/p>\n<p>\u2022 Develop and maintain standard operating procedures (SOPs) for operational and safety processes.<\/p>\n<p>\u2022 Provide technical guidance to ensure site compliance with environmental and regulatory requirements.<\/p>\n<p><strong><u>Other duties as required.<\/u><\/strong><\/p>\n<p><strong>The Ideal Candidate:<\/strong><\/p>\n<p><strong>Education and Experience<\/strong><\/p>\n<p>\u2022 Mining or Civil Engineering Degree or related.<\/p>\n<p>\u2022 3 years of mine site engineering or operational experience.<\/p>\n<p>\u2022 Hands-on experience with mining engineering software (Hexagon MineSight preferred or similar).<\/p>\n<p>\u2022 Strong proficiency in MS Office (Word, Excel, PowerPoint, Outlook).<\/p>\n<p>\u2022 Part 107 drone license preferred<\/p>\n<p>\u2022 Procurement and mine accounting experience preferred<\/p>\n<p><strong>Technical and Analytical Skills<\/strong><\/p>\n<p>\u2022 Strong problem-solving and data analysis capabilities.<\/p>\n<p>\u2022 Ability to translate complex engineering data into actionable recommendations.<\/p>\n<p>\u2022 Knowledge of drill &amp; blast design, mine haulage analysis, and GPS fleet management.<\/p>\n<p>\u2022 Familiarity with mine accounting and procurement processes (preferred but not required).<\/p>\n<p><strong>Key Competencies \/ Skills<\/strong><\/p>\n<p>\u2022 Results-oriented with a proactive, problem-solving mindset.<\/p>\n<p>\u2022 Effective communicator, capable of working with cross-functional teams and clients.<\/p>\n<p>\u2022 Ability to work independently and manage multiple priorities in a dynamic environment.<\/p>\n<p>\u2022 Detail-oriented with strong documentation and technical writing skills.<\/p>","%category%":"Operations","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/00b9cc6c3510-project-engineer","%breezy_id%":"00b9cc6c3510","%breezy_friendly_id%":"00b9cc6c3510-project-engineer","%breezy_created_date%":"2025-02-17T21:52:34.180Z","%breezy_updated_date%":"2025-02-17T21:54:45.493Z","%_wpgmp_location_city%":"Kingman","%_wpgmp_location_state%":"AZ","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Kingman, AZ, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"35.1912977","%_wpgmp_metabox_longitude%":"-114.0522845","%rank_math_internal_links_processed%":"1"}},"id":2167,"infowindow_disable":false},{"source":"post","title":"Senior Project Manager- Civil Works Projects","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Senior Project Manager- Civil Works Projects\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    We are seeking a&nbsp;Senior Project Manager that&nbsp;oversees the planning, execution, and closure of complex civil works projects, including flood risk&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/senior-project-manager-civil-works-projects\/\" name=\"Senior Project Manager- Civil Works Projects\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"We are seeking a&nbsp;Senior Project Manager that&nbsp;oversees the planning, execution, and closure of complex civil works projects, including flood risk&hellip;","address":"East Moline, IL, USA","location":{"lat":"41.5008673","city":"East Moline","state":"IL","country":"United States","lng":"-90.4442979","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/senior-project-manager-civil-works-projects\/","zoom":19,"extra_fields":{"post_excerpt":"We are seeking a&nbsp;Senior Project Manager that&nbsp;oversees the planning, execution, and closure of complex civil works projects, including flood risk&hellip;","post_content":"<p><strong>We are seeking a&nbsp;Senior Project Manager that<\/strong>&nbsp;<strong>oversees the planning, execution, and closure of complex civil works projects, including flood risk management, navigation, hydropower, dredging, ecosystem restoration, and water supply, leading large teams through all project phases while ensuring adherence to budget, schedule, and environmental regulations, often requiring extensive stakeholder coordination and technical expertise in managing large-scale infrastructure projects<\/strong>. <\/p>\n<p><strong>Key responsibilities may include: <\/strong><\/p>\n<ul>\n <li><strong>Project      Leadership:<\/strong> Leading multidisciplinary teams throughout the project      lifecycle, from planning and design to construction and operations,      managing complex project schedules and budgets.&nbsp; <\/li>\n <li><strong>Technical      Expertise:<\/strong> Applying advanced engineering knowledge to evaluate project      feasibility, develop design solutions, and oversee technical aspects of      construction, including quality control. <\/li>\n <li><strong>Stakeholder      Management:<\/strong> Collaborating with diverse stakeholders including federal,      state, and local agencies, community groups, and private entities to      address concerns and build consensus on project goals. <\/li>\n <li><strong>Environmental      Compliance:<\/strong> Ensuring project compliance with environmental regulations      and permitting processes, considering potential environmental impacts and      mitigation strategies. <\/li>\n <li><strong>Risk      Management:<\/strong> Identifying, assessing, and mitigating project risks      through proactive planning and contingency measures. <\/li>\n <li><strong>Contract      Administration:<\/strong> Managing contracts with contractors, reviewing      proposals, and monitoring performance against contract specifications <\/li>\n <li><strong>Reporting      and Communication:<\/strong> Providing regular updates to senior leadership on      project progress, including financial status, schedule adherence, and key      milestones.&nbsp; <\/li>\n <li><strong>Public      Outreach:<\/strong> Communicating project details to the public, addressing      concerns, and facilitating community engagement.&nbsp; <\/li>\n<\/ul>\n<p><strong>Required qualifications: <\/strong><\/p>\n<ul>\n <li>Bachelor's      degree in Civil Engineering or a related field <\/li>\n <li>Professional      Engineer (PE) license preferred <\/li>\n <li>Extensive      experience in project management, preferably within the Army Corps of      Engineers <\/li>\n <li>Demonstrated      ability to lead large, complex projects with significant budget and      schedule constraints <\/li>\n <li>Strong      understanding of federal regulations and permitting processes related to      water resource projects <\/li>\n <li>Excellent      communication, interpersonal, and negotiation skills <\/li>\n <li>Experience      with dredging contracts would be a plus. <\/li>\n<\/ul>","post_title":"Senior Project Manager- Civil Works Projects","post_link":"https:\/\/turnerstaffing.com\/position\/senior-project-manager-civil-works-projects\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Senior","%location_country%":"United States","%location_city%":"East Moline","%location_state_id%":"IL","%location_state_name%":"Illinois","%location_city_state%":"East Moline, IL","%education%":"Bachelor's Degree","%department%":"","%description%":"<p><strong>We are seeking a&nbsp;Senior Project Manager that<\/strong>&nbsp;<strong>oversees the planning, execution, and closure of complex civil works projects, including flood risk management, navigation, hydropower, dredging, ecosystem restoration, and water supply, leading large teams through all project phases while ensuring adherence to budget, schedule, and environmental regulations, often requiring extensive stakeholder coordination and technical expertise in managing large-scale infrastructure projects<\/strong>. <\/p>\n<p><strong>Key responsibilities may include: <\/strong><\/p>\n<ul>\n <li><strong>Project      Leadership:<\/strong> Leading multidisciplinary teams throughout the project      lifecycle, from planning and design to construction and operations,      managing complex project schedules and budgets.&nbsp; <\/li>\n <li><strong>Technical      Expertise:<\/strong> Applying advanced engineering knowledge to evaluate project      feasibility, develop design solutions, and oversee technical aspects of      construction, including quality control. <\/li>\n <li><strong>Stakeholder      Management:<\/strong> Collaborating with diverse stakeholders including federal,      state, and local agencies, community groups, and private entities to      address concerns and build consensus on project goals. <\/li>\n <li><strong>Environmental      Compliance:<\/strong> Ensuring project compliance with environmental regulations      and permitting processes, considering potential environmental impacts and      mitigation strategies. <\/li>\n <li><strong>Risk      Management:<\/strong> Identifying, assessing, and mitigating project risks      through proactive planning and contingency measures. <\/li>\n <li><strong>Contract      Administration:<\/strong> Managing contracts with contractors, reviewing      proposals, and monitoring performance against contract specifications <\/li>\n <li><strong>Reporting      and Communication:<\/strong> Providing regular updates to senior leadership on      project progress, including financial status, schedule adherence, and key      milestones.&nbsp; <\/li>\n <li><strong>Public      Outreach:<\/strong> Communicating project details to the public, addressing      concerns, and facilitating community engagement.&nbsp; <\/li>\n<\/ul>\n<p><strong>Required qualifications: <\/strong><\/p>\n<ul>\n <li>Bachelor's      degree in Civil Engineering or a related field <\/li>\n <li>Professional      Engineer (PE) license preferred <\/li>\n <li>Extensive      experience in project management, preferably within the Army Corps of      Engineers <\/li>\n <li>Demonstrated      ability to lead large, complex projects with significant budget and      schedule constraints <\/li>\n <li>Strong      understanding of federal regulations and permitting processes related to      water resource projects <\/li>\n <li>Excellent      communication, interpersonal, and negotiation skills <\/li>\n <li>Experience      with dredging contracts would be a plus. <\/li>\n<\/ul>","%category%":"Management","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/6c41ec712603-senior-project-manager-civil-works-projects","%breezy_id%":"6c41ec712603","%breezy_friendly_id%":"6c41ec712603-senior-project-manager-civil-works-projects","%breezy_created_date%":"2025-02-13T15:37:37.884Z","%breezy_updated_date%":"2025-02-13T16:06:44.732Z","%_wpgmp_location_city%":"East Moline","%_wpgmp_location_state%":"IL","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"East Moline, IL, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"41.5008673","%_wpgmp_metabox_longitude%":"-90.4442979","%rank_math_internal_links_processed%":"1"}},"id":2156,"infowindow_disable":false},{"source":"post","title":"Dredge Site Safety and Health Officer","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Dredge Site Safety and Health Officer\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Job Summary: We are seeking a highly skilled and experienced Dredge Site Safety and Health Officer to oversee and ensure&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/dredge-site-safety-and-health-officer\/\" name=\"Dredge Site Safety and Health Officer\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Job Summary: We are seeking a highly skilled and experienced Dredge Site Safety and Health Officer to oversee and ensure&hellip;","address":"Guttenberg, IA, USA","location":{"lat":"42.7899897","city":"Guttenberg","state":"IA","country":"United States","lng":"-91.1029068","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/dredge-site-safety-and-health-officer\/","zoom":19,"extra_fields":{"post_excerpt":"Job Summary: We are seeking a highly skilled and experienced Dredge Site Safety and Health Officer to oversee and ensure&hellip;","post_content":"<h3><strong>Job Summary:<\/strong><\/h3>\n<p>We are seeking a highly skilled and experienced <strong>Dredge Site Safety and Health Officer<\/strong> to oversee and ensure the safety and health protocols on dredging project sites. The ideal candidate will have hands-on experience working on dredging projects and a strong understanding of the <strong>EM385<\/strong> (U.S. Army Corps of Engineers Safety and Health Manual) standards. As a key member of our team, the Safety and Health Officer will play a critical role in promoting a safe work environment, ensuring regulatory compliance, and mitigating risks on-site.<\/p>\n<h3><strong>Key Responsibilities:<\/strong><\/h3>\n<ul><li><strong>Safety Oversight<\/strong>: Monitor daily operations of dredging projects to ensure that all safety protocols are adhered to, including the handling of equipment, materials, and personnel.<\/li><li><strong>Risk Assessment<\/strong>: Conduct regular safety assessments and hazard analyses on dredge sites, identifying potential risks and implementing corrective actions to prevent accidents.<\/li><li><strong>Compliance Management<\/strong>: Ensure compliance with all relevant health, safety, and environmental regulations, particularly those outlined in the <strong>EM385 manual<\/strong>, OSHA standards, and company-specific procedures.<\/li><li><strong>Safety Training<\/strong>: Provide safety training and orientation for all site personnel, ensuring that they are familiar with emergency response plans, hazard communication, PPE (Personal Protective Equipment) requirements, and safe work practices.<\/li><li><strong>Accident Investigation<\/strong>: Lead investigations into any safety incidents or accidents, identifying root causes and recommending corrective actions to prevent future occurrences.<\/li><li><strong>Safety Reporting<\/strong>: Maintain and submit accurate safety reports, incident logs, and risk assessments to senior management and regulatory bodies as required.<\/li><li><strong>Site Inspections<\/strong>: Conduct regular inspections of dredging operations, equipment, and personnel, ensuring that safety equipment is functioning properly and that the work environment is hazard-free.<\/li><li><strong>Emergency Response Planning<\/strong>: Develop, implement, and regularly update emergency response plans for dredging activities, including spill containment, medical emergencies, and evacuation procedures.<\/li><li><strong>Stakeholder Communication<\/strong>: Collaborate with project managers, engineers, and other stakeholders to ensure safety is prioritized in all aspects of the dredging project.<\/li><\/ul>\n<h3><strong>Requirements:<\/strong><\/h3>\n<ul><li><strong>Experience<\/strong>: Minimum of 5 years of experience working on dredge project sites, with a strong understanding of dredging operations and associated risks.<\/li><li><strong>Certifications<\/strong>: OSHA 30-Hour Construction Safety Certification and\/or other relevant safety certifications.<\/li><li><strong>EM385 Knowledge<\/strong>: In-depth understanding of the <strong>EM385 Safety and Health Manual<\/strong> (U.S. Army Corps of Engineers) and its application on dredging sites.<\/li><li><strong>Training and Communication<\/strong>: Strong communication skills with the ability to deliver safety training, prepare reports, and work collaboratively with diverse teams.<\/li><li><strong>Problem Solving<\/strong>: Ability to quickly assess situations, identify potential risks, and implement practical solutions to ensure the safety of all site personnel.<\/li><li><strong>Physical Requirements<\/strong>: Must be able to work in a physically demanding environment, including exposure to outdoor elements and the dredging site atmosphere.<\/li><li><strong>First Aid &amp; CPR<\/strong>: Certification in First Aid and CPR preferred.<\/li><\/ul>\n<h3><strong>Preferred Qualifications:<\/strong><\/h3>\n<ul><li>Familiarity with additional safety management systems such as ISO 45001.<\/li><li>Previous experience in a supervisory role overseeing safety on large-scale civil or construction projects.<\/li><li>Ability to manage and work with a diverse team of employees and contractors.<\/li><\/ul>\n<h3><strong>Benefits:<\/strong><\/h3>\n<ul><li>Competitive salary and benefits package.<\/li><li>Opportunity for career advancement in a growing company.<\/li><li>Supportive work environment focused on safety and professional growth<\/li><\/ul>","post_title":"Dredge Site Safety and Health Officer","post_link":"https:\/\/turnerstaffing.com\/position\/dredge-site-safety-and-health-officer\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Senior","%location_country%":"United States","%location_city%":"Guttenberg","%location_state_id%":"IA","%location_state_name%":"Iowa","%location_city_state%":"Guttenberg, IA","%education%":"Bachelor's Degree","%department%":"","%description%":"<h3><strong>Job Summary:<\/strong><\/h3>\n<p>We are seeking a highly skilled and experienced <strong>Dredge Site Safety and Health Officer<\/strong> to oversee and ensure the safety and health protocols on dredging project sites. The ideal candidate will have hands-on experience working on dredging projects and a strong understanding of the <strong>EM385<\/strong> (U.S. Army Corps of Engineers Safety and Health Manual) standards. As a key member of our team, the Safety and Health Officer will play a critical role in promoting a safe work environment, ensuring regulatory compliance, and mitigating risks on-site.<\/p>\n<h3><strong>Key Responsibilities:<\/strong><\/h3>\n<ul><li><strong>Safety Oversight<\/strong>: Monitor daily operations of dredging projects to ensure that all safety protocols are adhered to, including the handling of equipment, materials, and personnel.<\/li><li><strong>Risk Assessment<\/strong>: Conduct regular safety assessments and hazard analyses on dredge sites, identifying potential risks and implementing corrective actions to prevent accidents.<\/li><li><strong>Compliance Management<\/strong>: Ensure compliance with all relevant health, safety, and environmental regulations, particularly those outlined in the <strong>EM385 manual<\/strong>, OSHA standards, and company-specific procedures.<\/li><li><strong>Safety Training<\/strong>: Provide safety training and orientation for all site personnel, ensuring that they are familiar with emergency response plans, hazard communication, PPE (Personal Protective Equipment) requirements, and safe work practices.<\/li><li><strong>Accident Investigation<\/strong>: Lead investigations into any safety incidents or accidents, identifying root causes and recommending corrective actions to prevent future occurrences.<\/li><li><strong>Safety Reporting<\/strong>: Maintain and submit accurate safety reports, incident logs, and risk assessments to senior management and regulatory bodies as required.<\/li><li><strong>Site Inspections<\/strong>: Conduct regular inspections of dredging operations, equipment, and personnel, ensuring that safety equipment is functioning properly and that the work environment is hazard-free.<\/li><li><strong>Emergency Response Planning<\/strong>: Develop, implement, and regularly update emergency response plans for dredging activities, including spill containment, medical emergencies, and evacuation procedures.<\/li><li><strong>Stakeholder Communication<\/strong>: Collaborate with project managers, engineers, and other stakeholders to ensure safety is prioritized in all aspects of the dredging project.<\/li><\/ul>\n<h3><strong>Requirements:<\/strong><\/h3>\n<ul><li><strong>Experience<\/strong>: Minimum of 5 years of experience working on dredge project sites, with a strong understanding of dredging operations and associated risks.<\/li><li><strong>Certifications<\/strong>: OSHA 30-Hour Construction Safety Certification and\/or other relevant safety certifications.<\/li><li><strong>EM385 Knowledge<\/strong>: In-depth understanding of the <strong>EM385 Safety and Health Manual<\/strong> (U.S. Army Corps of Engineers) and its application on dredging sites.<\/li><li><strong>Training and Communication<\/strong>: Strong communication skills with the ability to deliver safety training, prepare reports, and work collaboratively with diverse teams.<\/li><li><strong>Problem Solving<\/strong>: Ability to quickly assess situations, identify potential risks, and implement practical solutions to ensure the safety of all site personnel.<\/li><li><strong>Physical Requirements<\/strong>: Must be able to work in a physically demanding environment, including exposure to outdoor elements and the dredging site atmosphere.<\/li><li><strong>First Aid &amp; CPR<\/strong>: Certification in First Aid and CPR preferred.<\/li><\/ul>\n<h3><strong>Preferred Qualifications:<\/strong><\/h3>\n<ul><li>Familiarity with additional safety management systems such as ISO 45001.<\/li><li>Previous experience in a supervisory role overseeing safety on large-scale civil or construction projects.<\/li><li>Ability to manage and work with a diverse team of employees and contractors.<\/li><\/ul>\n<h3><strong>Benefits:<\/strong><\/h3>\n<ul><li>Competitive salary and benefits package.<\/li><li>Opportunity for career advancement in a growing company.<\/li><li>Supportive work environment focused on safety and professional growth<\/li><\/ul>","%category%":"Operations","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/4ad2cd78f6fb-dredge-site-safety-and-health-officer","%breezy_id%":"4ad2cd78f6fb","%breezy_friendly_id%":"4ad2cd78f6fb-dredge-site-safety-and-health-officer","%breezy_created_date%":"2025-02-13T19:17:54.066Z","%breezy_updated_date%":"2025-02-13T21:46:53.547Z","%_wpgmp_location_city%":"Guttenberg","%_wpgmp_location_state%":"IA","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Guttenberg, IA, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"42.7899897","%_wpgmp_metabox_longitude%":"-91.1029068","%rank_math_internal_links_processed%":"1"}},"id":2157,"infowindow_disable":false},{"source":"post","title":"Senior Electrical Project Manager","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Senior Electrical Project Manager\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Our client&nbsp;is currently seeking a Senior Project Manager for an immediate opening in Cedar Rapids, IA. The Senior Project Manager&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/senior-electrical-project-manager-2\/\" name=\"Senior Electrical Project Manager\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Our client&nbsp;is currently seeking a Senior Project Manager for an immediate opening in Cedar Rapids, IA. The Senior Project Manager&hellip;","address":"Cedar Rapids, IA, USA","location":{"lat":"41.9778795","city":"Cedar Rapids","state":"IA","country":"United States","lng":"-91.6656232","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/senior-electrical-project-manager-2\/","zoom":19,"extra_fields":{"post_excerpt":"Our client&nbsp;is currently seeking a Senior Project Manager for an immediate opening in Cedar Rapids, IA. The Senior Project Manager&hellip;","post_content":"<p>Our client&nbsp;is currently seeking a Senior Project Manager for an immediate opening in Cedar Rapids, IA. The Senior Project Manager will be responsible for providing&nbsp;overall on-site administrative and technical management on mission critical construction projects for our electrical division.&nbsp;<\/p>\n<p>Responsibilities include but are not limited to:<\/p>\n<ul><li>Supervising total construction effort to ensure project is constructed in accordance with design, budget, and schedule (includes interfacing with customer representatives, A-E representatives, other contractors, etc.)<\/li><li>Planning, coordinating, and supervising on-site functions (scheduling, engineering, material control, and may provide day-to-day direction of on-site administrative staff in accounting, purchasing, etc.)<\/li><li>Supervising craft employees and\/or other contractors as required by the contract<\/li><li>Providing technical assistance, e.g. interpretation of drawings, recommending construction methods and equipment, etc., as required<\/li><li>Initiating and providing extra work estimating and issuance of change orders<\/li><li>Assuming responsibility for productivity of crafts, efficient use of materials and equipment, and contractual performance of the project<\/li><li>Fostering and maintaining good morale and positive relationships with customers, field and\/or office personnel<\/li><li>Participating as a team in calling on and selling customers on potential project<\/li><li>Performing additional assignments per management\u2019s direction<\/li><\/ul>\n<p>Qualifications:<\/p>\n<ul><li>Bachelor\u2019s Degree in Business, Finance, Construction Management, or related industry<\/li><li>10+ years of related experience<\/li><li>Equivalent combination of education\/experience<\/li><\/ul>\n<p>Candidates must possess strong attention to detail, focus on accuracy, solid communication skills, a strong mechanical aptitude, positive initiative and judgement, the ability to problem solve and meet deadlines and the ability to multitask with tact and consideration.<\/p>","post_title":"Senior Electrical Project Manager","post_link":"https:\/\/turnerstaffing.com\/position\/senior-electrical-project-manager-2\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Senior","%location_country%":"United States","%location_city%":"Cedar Rapids","%location_state_id%":"IA","%location_state_name%":"Iowa","%location_city_state%":"Cedar Rapids, IA","%education%":"Bachelor's Degree","%department%":"","%description%":"<p>Our client&nbsp;is currently seeking a Senior Project Manager for an immediate opening in Cedar Rapids, IA. The Senior Project Manager will be responsible for providing&nbsp;overall on-site administrative and technical management on mission critical construction projects for our electrical division.&nbsp;<\/p>\n<p>Responsibilities include but are not limited to:<\/p>\n<ul><li>Supervising total construction effort to ensure project is constructed in accordance with design, budget, and schedule (includes interfacing with customer representatives, A-E representatives, other contractors, etc.)<\/li><li>Planning, coordinating, and supervising on-site functions (scheduling, engineering, material control, and may provide day-to-day direction of on-site administrative staff in accounting, purchasing, etc.)<\/li><li>Supervising craft employees and\/or other contractors as required by the contract<\/li><li>Providing technical assistance, e.g. interpretation of drawings, recommending construction methods and equipment, etc., as required<\/li><li>Initiating and providing extra work estimating and issuance of change orders<\/li><li>Assuming responsibility for productivity of crafts, efficient use of materials and equipment, and contractual performance of the project<\/li><li>Fostering and maintaining good morale and positive relationships with customers, field and\/or office personnel<\/li><li>Participating as a team in calling on and selling customers on potential project<\/li><li>Performing additional assignments per management\u2019s direction<\/li><\/ul>\n<p>Qualifications:<\/p>\n<ul><li>Bachelor\u2019s Degree in Business, Finance, Construction Management, or related industry<\/li><li>10+ years of related experience<\/li><li>Equivalent combination of education\/experience<\/li><\/ul>\n<p>Candidates must possess strong attention to detail, focus on accuracy, solid communication skills, a strong mechanical aptitude, positive initiative and judgement, the ability to problem solve and meet deadlines and the ability to multitask with tact and consideration.<\/p>","%category%":"Management","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/5deb8cf4c9b4-senior-electrical-project-manager","%breezy_id%":"5deb8cf4c9b4","%breezy_friendly_id%":"5deb8cf4c9b4-senior-electrical-project-manager","%breezy_created_date%":"2025-02-06T21:47:19.946Z","%breezy_updated_date%":"2025-02-06T21:47:55.016Z","%_wpgmp_location_city%":"Cedar Rapids","%_wpgmp_location_state%":"IA","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Cedar Rapids, IA, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"41.9778795","%_wpgmp_metabox_longitude%":"-91.6656232","%rank_math_internal_links_processed%":"1"}},"id":2144,"infowindow_disable":false},{"source":"post","title":"Senior Electrical Project Manager","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Senior Electrical Project Manager\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Our client&nbsp;is currently seeking a Senior Project Manager for an immediate opening in South Bend, IN. The Senior Project Manager&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/senior-electrical-project-manager\/\" name=\"Senior Electrical Project Manager\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Our client&nbsp;is currently seeking a Senior Project Manager for an immediate opening in South Bend, IN. The Senior Project Manager&hellip;","address":"South Bend, IN, USA","location":{"lat":"41.6763545","city":"South Bend","state":"IN","country":"United States","lng":"-86.2519898","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/senior-electrical-project-manager\/","zoom":19,"extra_fields":{"post_excerpt":"Our client&nbsp;is currently seeking a Senior Project Manager for an immediate opening in South Bend, IN. The Senior Project Manager&hellip;","post_content":"<p>Our client&nbsp;is currently seeking a Senior Project Manager for an immediate opening in South Bend, IN. The Senior Project Manager will be responsible for providing overall on-site administrative and technical management on mission critical construction projects for our electrical division.&nbsp;<\/p>\n<p>Responsibilities include but are not limited to:<\/p>\n<ul><li>Supervising total construction effort to ensure project is constructed in accordance with design, budget, and schedule (includes interfacing with customer representatives, A-E representatives, other contractors, etc.)<\/li><li>Planning, coordinating, and supervising on-site functions (scheduling, engineering, material control, and may provide day-to-day direction of on-site administrative staff in accounting, purchasing, etc.)<\/li><li>Supervising craft employees and\/or other contractors as required by the contract<\/li><li>Providing technical assistance, e.g. interpretation of drawings, recommending construction methods and equipment, etc., as required<\/li><li>Initiating and providing extra work estimating and issuance of change orders<\/li><li>Assuming responsibility for productivity of crafts, efficient use of materials and equipment, and contractual performance of the project<\/li><li>Fostering and maintaining good morale and positive relationships with customers, field and\/or office personnel<\/li><li>Participating as a team in calling on and selling customers on potential project<\/li><li>Performing additional assignments per management\u2019s direction<\/li><\/ul>\n<p>Qualifications:<\/p>\n<ul><li>Bachelor\u2019s Degree in Business, Finance, Construction Management, or related industry<\/li><li>10+ years of related experience<\/li><li>Equivalent combination of education\/experience<\/li><\/ul>\n<p>Candidates must possess strong attention to detail, focus on accuracy, solid communication skills, a strong mechanical aptitude, positive initiative and judgement, the ability to problem solve and meet deadlines and the ability to multitask with tact and consideration.<\/p>","post_title":"Senior Electrical Project Manager","post_link":"https:\/\/turnerstaffing.com\/position\/senior-electrical-project-manager\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Senior","%location_country%":"United States","%location_city%":"South Bend","%location_state_id%":"IN","%location_state_name%":"Indiana","%location_city_state%":"South Bend, IN","%education%":"Bachelor's Degree","%department%":"","%description%":"<p>Our client&nbsp;is currently seeking a Senior Project Manager for an immediate opening in South Bend, IN. The Senior Project Manager will be responsible for providing overall on-site administrative and technical management on mission critical construction projects for our electrical division.&nbsp;<\/p>\n<p>Responsibilities include but are not limited to:<\/p>\n<ul><li>Supervising total construction effort to ensure project is constructed in accordance with design, budget, and schedule (includes interfacing with customer representatives, A-E representatives, other contractors, etc.)<\/li><li>Planning, coordinating, and supervising on-site functions (scheduling, engineering, material control, and may provide day-to-day direction of on-site administrative staff in accounting, purchasing, etc.)<\/li><li>Supervising craft employees and\/or other contractors as required by the contract<\/li><li>Providing technical assistance, e.g. interpretation of drawings, recommending construction methods and equipment, etc., as required<\/li><li>Initiating and providing extra work estimating and issuance of change orders<\/li><li>Assuming responsibility for productivity of crafts, efficient use of materials and equipment, and contractual performance of the project<\/li><li>Fostering and maintaining good morale and positive relationships with customers, field and\/or office personnel<\/li><li>Participating as a team in calling on and selling customers on potential project<\/li><li>Performing additional assignments per management\u2019s direction<\/li><\/ul>\n<p>Qualifications:<\/p>\n<ul><li>Bachelor\u2019s Degree in Business, Finance, Construction Management, or related industry<\/li><li>10+ years of related experience<\/li><li>Equivalent combination of education\/experience<\/li><\/ul>\n<p>Candidates must possess strong attention to detail, focus on accuracy, solid communication skills, a strong mechanical aptitude, positive initiative and judgement, the ability to problem solve and meet deadlines and the ability to multitask with tact and consideration.<\/p>","%category%":"Management","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/b1767dd077a4-senior-electrical-project-manager","%breezy_id%":"b1767dd077a4","%breezy_friendly_id%":"b1767dd077a4-senior-electrical-project-manager","%breezy_created_date%":"2025-02-06T21:42:28.664Z","%breezy_updated_date%":"2025-02-06T21:45:38.140Z","%_wpgmp_location_city%":"South Bend","%_wpgmp_location_state%":"IN","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"South Bend, IN, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"41.6763545","%_wpgmp_metabox_longitude%":"-86.2519898","%rank_math_internal_links_processed%":"1"}},"id":2143,"infowindow_disable":false},{"source":"post","title":"Corporate Mining Engineer","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Corporate Mining Engineer\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Corporate Mining Engineer Advisor to Project Management and the Executive and Operational Leadership Teams Reports to Director Of Operations Reporting&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/corporate-mining-engineer\/\" name=\"Corporate Mining Engineer\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Corporate Mining Engineer Advisor to Project Management and the Executive and Operational Leadership Teams Reports to Director Of Operations Reporting&hellip;","address":"Bloomington, IN, USA","location":{"lat":"39.169574","city":"Bloomington","state":"IN","country":"United States","lng":"-86.5385549","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/corporate-mining-engineer\/","zoom":19,"extra_fields":{"post_excerpt":"Corporate Mining Engineer Advisor to Project Management and the Executive and Operational Leadership Teams Reports to Director Of Operations Reporting&hellip;","post_content":"<p><strong>Corporate Mining Engineer<\/strong><\/p>\n<p><strong>Advisor to Project Management and the Executive and Operational Leadership Teams<\/strong><\/p>\n<p><strong>Reports to Director Of Operations<\/strong><\/p>\n<p>Reporting to the Director of Operations, the Corporate Mining Engineer plays a crucial role in bridging technical mining expertise with strategic business insights to drive operational efficiency, financial performance, and long-term growth. This position is responsible for analyzing operational data, preparing financial models, conducting technical due diligence, and supporting key decision-making processes across the organization.<\/p>\n<p>By integrating engineering principles with business intelligence, the role provides critical support for optimizing mining operations, identifying cost-saving opportunities, and evaluating potential investments. Additionally, it involves collaboration with cross-functional teams, ensuring alignment between corporate objectives, site-level execution, and regulatory compliance.<\/p>\n<p>This role requires a strong analytical mindset, industry knowledge, and the ability to synthesize complex data into actionable recommendations. With a focus on continuous improvement, sustainability, and strategic planning, the Corporate Mining Engineer is integral to enhancing both operational performance and corporate values at Turner Mining Group.<\/p>\n<p><strong><u>Position Responsibilities:<\/u><\/strong><\/p>\n<p><strong>Operational &amp; Technical Analysis<\/strong><\/p>\n<p>\u2022\tReview all operations reporting (cost, health and safety, operation, and production reports) and synthesize data and findings. Analyze findings for key themes and trends.<\/p>\n<p>\u2022\tConduct benchmarking of industry participants to identify best practices and competitive insights.<\/p>\n<p>\u2022\tSupport the development of operational objectives by studying business functions, gathering information, and evaluating output requirements and formats.<\/p>\n<p>\u2022\tDevelop and implement continuous improvement initiatives to enhance operational efficiencies and reduce costs.<\/p>\n<p>\u2022\tConduct risk assessments related to operational, technical, and financial aspects of mining projects.<\/p>\n<p>\u2022\tCollaborate with engineering and operations teams to optimize mine planning, design, and extraction techniques.<\/p>\n<p>\u2022\tAssess and recommend new mining technologies, automation, and digitalization strategies.<\/p>\n<p>\u2022\tDevelop and track key performance indicators (KPIs) to monitor operational performance and recommend improvements.<\/p>\n<p>\u2022\tLead the development of operations business intelligence initiatives.<\/p>\n<p><strong>Financial &amp; Strategic Analysis<\/strong><\/p>\n<p>\u2022\tPrepare operating cost models to support project evaluations.<\/p>\n<p>\u2022\tAssist in the technical due diligence process for mergers, acquisitions, and project assessments.<\/p>\n<p>\u2022\tSupport financial analysis on potential transactions and on pre-feasibility and feasibility stage projects.<\/p>\n<p>\u2022\tAssist management in special projects such as operations strategy and cash flow analysis.<\/p>\n<p>\u2022\tSupport the preparation of business case summary reports and recommendations.<\/p>\n<p>\u2022\tParticipate, support, or take leadership roles on business-related projects, benchmarking, and cost analysis.<\/p>\n<p>\u2022\tAssist in the preparation of investment and capital expenditure proposals for operational improvements.<\/p>\n<p>\u2022\tEvaluate the impact of market trends, commodity pricing, and regulatory changes on business performance.<\/p>\n<p>\u2022\tDevelop dashboards and data visualization tools to enhance decision-making across departments.<\/p>\n<p>\u2022\tSupport the development of long-term business strategy by integrating financial, technical, and operational insights.<\/p>\n<p>\u2022\tAssist in scenario modeling and sensitivity analysis for potential expansion or optimization projects.<\/p>\n<p>\u2022\tContribute to the preparation of financial plans at the operations level as required and consolidate submissions into a comprehensive model.<\/p>\n<p><strong>Stakeholder &amp; Cross-Functional Collaboration<\/strong><\/p>\n<p>\u2022\tLiaise with key departments and stakeholders to understand business needs and priorities, and actively participate in the development and delivery of technology solutions.<\/p>\n<p>\u2022\tAct as a liaison between corporate leadership, site management, and external consultants to ensure alignment on operational objectives.<\/p>\n<p>\u2022\tFacilitate knowledge-sharing initiatives, such as internal workshops and training, to improve operational and analytical capabilities across teams.<\/p>\n<p>\u2022\tEngage with suppliers and service providers to optimize procurement strategies for mining operations.<\/p>\n<p>\u2022\tContribute to supporting operations with ad-hoc mandates as needed.<\/p>\n<p><strong>Other Responsibilities<\/strong><\/p>\n<p>\u2022\tReview and consolidate operational reports for senior management.<\/p>\n<p>\u2022\tParticipate in strategic planning sessions and contribute insights to corporate decision-making.<\/p>\n<p>\u2022\tOther duties as required.<\/p>\n<p><strong><u>The Ideal Candidate:<\/u><\/strong><\/p>\n<p><strong>Knowledge<\/strong><\/p>\n<p>\u2022\tGeology, Metallurgy or Mining Degree, MBA preferred<\/p>\n<p>\u2022\tMining industry knowledge<\/p>\n<p>\u2022\tMine site operations experience<\/p>\n<p>\u2022\tTechnical knowledge<\/p>\n<p>\u2022\tStrong analytical skills<\/p>\n<p>\u2022\tFinance and business acumen skills<\/p>\n<p>\u2022\tStrong MS Office skills (Word, Excel, PowerPoint, Outlook)<\/p>\n<p><strong><u>Key Competencies\/Skills:<\/u><\/strong><\/p>\n<p>\u2022\tDependable, results-oriented, self-motivating<\/p>\n<p>\u2022\tProven ability to deliver in demanding environment<\/p>\n<p>\u2022\tIndependent minded<\/p>\n<p>\u2022\tBusiness analysis skills<\/p>\n<p>\u2022\tSolid documentation skills<\/p>","post_title":"Corporate Mining Engineer","post_link":"https:\/\/turnerstaffing.com\/position\/corporate-mining-engineer\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Associate","%location_country%":"United States","%location_city%":"Bloomington","%location_state_id%":"IN","%location_state_name%":"Indiana","%location_city_state%":"Bloomington, IN","%education%":"Bachelor's Degree","%department%":"Engineering","%description%":"<p><strong>Corporate Mining Engineer<\/strong><\/p>\n<p><strong>Advisor to Project Management and the Executive and Operational Leadership Teams<\/strong><\/p>\n<p><strong>Reports to Director Of Operations<\/strong><\/p>\n<p>Reporting to the Director of Operations, the Corporate Mining Engineer plays a crucial role in bridging technical mining expertise with strategic business insights to drive operational efficiency, financial performance, and long-term growth. This position is responsible for analyzing operational data, preparing financial models, conducting technical due diligence, and supporting key decision-making processes across the organization.<\/p>\n<p>By integrating engineering principles with business intelligence, the role provides critical support for optimizing mining operations, identifying cost-saving opportunities, and evaluating potential investments. Additionally, it involves collaboration with cross-functional teams, ensuring alignment between corporate objectives, site-level execution, and regulatory compliance.<\/p>\n<p>This role requires a strong analytical mindset, industry knowledge, and the ability to synthesize complex data into actionable recommendations. With a focus on continuous improvement, sustainability, and strategic planning, the Corporate Mining Engineer is integral to enhancing both operational performance and corporate values at Turner Mining Group.<\/p>\n<p><strong><u>Position Responsibilities:<\/u><\/strong><\/p>\n<p><strong>Operational &amp; Technical Analysis<\/strong><\/p>\n<p>\u2022\tReview all operations reporting (cost, health and safety, operation, and production reports) and synthesize data and findings. Analyze findings for key themes and trends.<\/p>\n<p>\u2022\tConduct benchmarking of industry participants to identify best practices and competitive insights.<\/p>\n<p>\u2022\tSupport the development of operational objectives by studying business functions, gathering information, and evaluating output requirements and formats.<\/p>\n<p>\u2022\tDevelop and implement continuous improvement initiatives to enhance operational efficiencies and reduce costs.<\/p>\n<p>\u2022\tConduct risk assessments related to operational, technical, and financial aspects of mining projects.<\/p>\n<p>\u2022\tCollaborate with engineering and operations teams to optimize mine planning, design, and extraction techniques.<\/p>\n<p>\u2022\tAssess and recommend new mining technologies, automation, and digitalization strategies.<\/p>\n<p>\u2022\tDevelop and track key performance indicators (KPIs) to monitor operational performance and recommend improvements.<\/p>\n<p>\u2022\tLead the development of operations business intelligence initiatives.<\/p>\n<p><strong>Financial &amp; Strategic Analysis<\/strong><\/p>\n<p>\u2022\tPrepare operating cost models to support project evaluations.<\/p>\n<p>\u2022\tAssist in the technical due diligence process for mergers, acquisitions, and project assessments.<\/p>\n<p>\u2022\tSupport financial analysis on potential transactions and on pre-feasibility and feasibility stage projects.<\/p>\n<p>\u2022\tAssist management in special projects such as operations strategy and cash flow analysis.<\/p>\n<p>\u2022\tSupport the preparation of business case summary reports and recommendations.<\/p>\n<p>\u2022\tParticipate, support, or take leadership roles on business-related projects, benchmarking, and cost analysis.<\/p>\n<p>\u2022\tAssist in the preparation of investment and capital expenditure proposals for operational improvements.<\/p>\n<p>\u2022\tEvaluate the impact of market trends, commodity pricing, and regulatory changes on business performance.<\/p>\n<p>\u2022\tDevelop dashboards and data visualization tools to enhance decision-making across departments.<\/p>\n<p>\u2022\tSupport the development of long-term business strategy by integrating financial, technical, and operational insights.<\/p>\n<p>\u2022\tAssist in scenario modeling and sensitivity analysis for potential expansion or optimization projects.<\/p>\n<p>\u2022\tContribute to the preparation of financial plans at the operations level as required and consolidate submissions into a comprehensive model.<\/p>\n<p><strong>Stakeholder &amp; Cross-Functional Collaboration<\/strong><\/p>\n<p>\u2022\tLiaise with key departments and stakeholders to understand business needs and priorities, and actively participate in the development and delivery of technology solutions.<\/p>\n<p>\u2022\tAct as a liaison between corporate leadership, site management, and external consultants to ensure alignment on operational objectives.<\/p>\n<p>\u2022\tFacilitate knowledge-sharing initiatives, such as internal workshops and training, to improve operational and analytical capabilities across teams.<\/p>\n<p>\u2022\tEngage with suppliers and service providers to optimize procurement strategies for mining operations.<\/p>\n<p>\u2022\tContribute to supporting operations with ad-hoc mandates as needed.<\/p>\n<p><strong>Other Responsibilities<\/strong><\/p>\n<p>\u2022\tReview and consolidate operational reports for senior management.<\/p>\n<p>\u2022\tParticipate in strategic planning sessions and contribute insights to corporate decision-making.<\/p>\n<p>\u2022\tOther duties as required.<\/p>\n<p><strong><u>The Ideal Candidate:<\/u><\/strong><\/p>\n<p><strong>Knowledge<\/strong><\/p>\n<p>\u2022\tGeology, Metallurgy or Mining Degree, MBA preferred<\/p>\n<p>\u2022\tMining industry knowledge<\/p>\n<p>\u2022\tMine site operations experience<\/p>\n<p>\u2022\tTechnical knowledge<\/p>\n<p>\u2022\tStrong analytical skills<\/p>\n<p>\u2022\tFinance and business acumen skills<\/p>\n<p>\u2022\tStrong MS Office skills (Word, Excel, PowerPoint, Outlook)<\/p>\n<p><strong><u>Key Competencies\/Skills:<\/u><\/strong><\/p>\n<p>\u2022\tDependable, results-oriented, self-motivating<\/p>\n<p>\u2022\tProven ability to deliver in demanding environment<\/p>\n<p>\u2022\tIndependent minded<\/p>\n<p>\u2022\tBusiness analysis skills<\/p>\n<p>\u2022\tSolid documentation skills<\/p>","%category%":"Operations","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/8c0eb7087b67-corporate-mining-engineer","%breezy_id%":"8c0eb7087b67","%breezy_friendly_id%":"8c0eb7087b67-corporate-mining-engineer","%breezy_created_date%":"2025-02-04T13:44:16.066Z","%breezy_updated_date%":"2025-03-18T12:56:34.494Z","%_wpgmp_location_city%":"Bloomington","%_wpgmp_location_state%":"IN","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Bloomington, IN, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"39.169574","%_wpgmp_metabox_longitude%":"-86.5385549","%rank_math_internal_links_processed%":"1"}},"id":2131,"infowindow_disable":false},{"source":"post","title":"Mine Mechanic","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Mine Mechanic\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Mine Mechanic Overview: Join our team as a Maintenance Mechanic where you will play a crucial role in ensuring the&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/mine-mechanic\/\" name=\"Mine Mechanic\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Mine Mechanic Overview: Join our team as a Maintenance Mechanic where you will play a crucial role in ensuring the&hellip;","address":"Gabbs, NV, USA","location":{"lat":"38.8690562","city":"Gabbs","state":"NV","country":"United States","lng":"-117.9228819","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/mine-mechanic\/","zoom":19,"extra_fields":{"post_excerpt":"Mine Mechanic Overview: Join our team as a Maintenance Mechanic where you will play a crucial role in ensuring the&hellip;","post_content":"<p>Mine Mechanic<\/p>\n<p>Overview:<\/p>\n<p>Join our team as a Maintenance Mechanic where you will play a crucial role in ensuring the smooth operation and maintenance of our facilities. As a Maintenance Mechanic, you will be responsible for performing a variety of tasks to support the upkeep of equipment and systems, contributing to the overall efficiency of our operations.<\/p>\n<p>Duties:<\/p>\n<p>- Conduct routine maintenance on machinery and equipment to ensure optimal functionality<br>- Diagnose mechanical issues and perform repairs promptly to minimize downtime<br>- Utilize schematics and technical manuals to troubleshoot and resolve problems effectively<br>- Collaborate with team members to prioritize and complete maintenance tasks efficiently<br>- Maintain accurate records of maintenance activities using Computerized Maintenance Management Systems (CMMS)<br>- Provide leadership and guidance to junior maintenance staff when necessary<br>- Assist in residential painting projects as needed<br>- Welding and electrical work as required<\/p>\n<p>Requirements:<\/p>\n<p>- Proficiency in English language for effective communication<br>- Strong customer service skills when interacting with internal teams<br>- Prior experience in a maintenance role, preferably in an industrial setting<br>- Ability to supervise and delegate tasks effectively<br>- Knowledge of electrical systems and equipment maintenance<br>- Familiarity with CMMS for tracking maintenance activities<br>- Welding skills for repairs and fabrication work<\/p>\n<p>If you are a proactive individual with a passion for maintaining equipment, troubleshooting issues, and ensuring operational efficiency, we invite you to apply for the Maintenance Mechanic position. Join us in upholding our commitment to excellence in facility maintenance.<\/p>","post_title":"Mine Mechanic","post_link":"https:\/\/turnerstaffing.com\/position\/mine-mechanic\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"","%location_country%":"United States","%location_city%":"Gabbs","%location_state_id%":"NV","%location_state_name%":"Nevada","%location_city_state%":"Gabbs, NV","%education%":"","%department%":"","%description%":"<p>Mine Mechanic<\/p>\n<p>Overview:<\/p>\n<p>Join our team as a Maintenance Mechanic where you will play a crucial role in ensuring the smooth operation and maintenance of our facilities. As a Maintenance Mechanic, you will be responsible for performing a variety of tasks to support the upkeep of equipment and systems, contributing to the overall efficiency of our operations.<\/p>\n<p>Duties:<\/p>\n<p>- Conduct routine maintenance on machinery and equipment to ensure optimal functionality<br>- Diagnose mechanical issues and perform repairs promptly to minimize downtime<br>- Utilize schematics and technical manuals to troubleshoot and resolve problems effectively<br>- Collaborate with team members to prioritize and complete maintenance tasks efficiently<br>- Maintain accurate records of maintenance activities using Computerized Maintenance Management Systems (CMMS)<br>- Provide leadership and guidance to junior maintenance staff when necessary<br>- Assist in residential painting projects as needed<br>- Welding and electrical work as required<\/p>\n<p>Requirements:<\/p>\n<p>- Proficiency in English language for effective communication<br>- Strong customer service skills when interacting with internal teams<br>- Prior experience in a maintenance role, preferably in an industrial setting<br>- Ability to supervise and delegate tasks effectively<br>- Knowledge of electrical systems and equipment maintenance<br>- Familiarity with CMMS for tracking maintenance activities<br>- Welding skills for repairs and fabrication work<\/p>\n<p>If you are a proactive individual with a passion for maintaining equipment, troubleshooting issues, and ensuring operational efficiency, we invite you to apply for the Maintenance Mechanic position. Join us in upholding our commitment to excellence in facility maintenance.<\/p>","%category%":"","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/5e35d728bf67-mine-mechanic","%breezy_id%":"5e35d728bf67","%breezy_friendly_id%":"5e35d728bf67-mine-mechanic","%breezy_created_date%":"2024-09-16T16:01:22.667Z","%breezy_updated_date%":"2025-02-24T18:38:01.854Z","%_wpgmp_location_city%":"Gabbs","%_wpgmp_location_state%":"NV","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Gabbs, NV, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"38.8690562","%_wpgmp_metabox_longitude%":"-117.9228819","%rank_math_internal_links_processed%":"1"}},"id":2130,"infowindow_disable":false},{"source":"post","title":"Maintenance Supervisor","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Maintenance Supervisor\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    POSITION SUMMARY: Responsible for the safe operations and front-line leadership of the Upper Shop\/Fixed Equipment at the Gabbs mine location.&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/maintenance-supervisor\/\" name=\"Maintenance Supervisor\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"POSITION SUMMARY: Responsible for the safe operations and front-line leadership of the Upper Shop\/Fixed Equipment at the Gabbs mine location.&hellip;","address":"Gabbs, NV, USA","location":{"lat":"38.8690562","city":"Gabbs","state":"NV","country":"United States","lng":"-117.9228819","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/maintenance-supervisor\/","zoom":19,"extra_fields":{"post_excerpt":"POSITION SUMMARY: Responsible for the safe operations and front-line leadership of the Upper Shop\/Fixed Equipment at the Gabbs mine location.&hellip;","post_content":"<p>POSITION SUMMARY:<\/p>\n<p>Responsible for the safe operations and front-line leadership of the Upper Shop\/Fixed Equipment at the Gabbs<\/p>\n<p>mine location. This position is a critical leadership role which requires the ability to lead and maintain a solid<\/p>\n<p>safety and performance record. This role is part of the site Maintenance Leadership team and will need to<\/p>\n<p>represent all decisions and direction the team makes together. This role must be able to work collaboratively<\/p>\n<p>with others to include their team.<\/p>\n<p><br><\/p><p>ESSENTIAL DUTIES AND RESPONSIBILITIES:<\/p>\n<p>\uf0b7 Responsible for the direct, daily leadership of all Upper Shop\/Fixed Equipment personnel.<\/p>\n<p>\uf0b7 Support and participate in Company Asset Care Strategy initiative<\/p>\n<p>\uf0b7 Implement production plans according to the approved schedule.<\/p>\n<p>\uf0b7 Inspect and evaluate work in progress, identifies any problem areas, and directs remedial action.<\/p>\n<p>\uf0b7 Work closely with operations teams to assess priorities of scheduled and break in work<\/p>\n<p>\uf0b7 Always operate within MSHA standards and company safety policies and procedures.<\/p>\n<p>\uf0b7 Effectively lead and participate in short- and long-term strategic planning initiatives.<\/p>\n<p>\uf0b7 Spend significant time in the field \u2013 \u201cvisible felt leadership\u201d \u2013 interacting with the workforce ~60 - 80%<\/p>\n<p>of working time.<\/p>\n<p>\uf0b7 Provide employees with a safe and healthy work environment by ensuring the provision of safe systems<\/p>\n<p>of work; safe work procedures; adequate training and instruction; competent supervision.<\/p>\n<p>\uf0b7 Performs other duties as assigned.<\/p>\n<p><br><\/p><p>Required Experience<\/p>\n<p>\uf0b7 5+ years in a Maintenance Lead or Supervision level or higher experience in mining industry<\/p>\n<p>\uf0b7 2+ years in compiling and\/or managing maintenance budgets<\/p>\n<p>\uf0b7 2+ years management of the maintenance scheduling and workflow function<\/p>\n<p>\uf0b7 Experience managing or supervising an equipment reliability program<\/p>\n<p>\uf0b7 A strong safety record and the ability to work with a variety of individuals<\/p>\n<p>\uf0b7 Ability to adapt information and communication style to the audience<\/p>\n<p>\uf0b7 Skilled at promoting teamwork to establish consensus among team and stakeholders<\/p>\n<p>\uf0b7 Capable of identifying key issues and patterns in moderately complex situations and spotting new, less<\/p>\n<p>obvious solutions<\/p>\n<p><br><\/p><p>Required Skills<\/p>\n<p>\uf0b7 Knowledge and unwavering dedication to safety and health compliance and principles.<\/p>\n<p>\uf0b7 Strong knowledge of Surface mining operations including HSE, Maintenance and Operations.<\/p>\n<p>\uf0b7 Strong written, verbal and interpersonal communication skills.<\/p>\n<p>\uf0b7 Proficient in problem solving and strong analytical skills.<\/p>\n<p>\uf0b7 Strong ability to influence, persuade and motivate individuals or groups to achieve desired outcomes in<\/p>\n<p>a professional and morally ethical way.<\/p>\n<p>\uf0b7 Must be efficient in the use of MS Office products (Excel, Outlook and Word) with experience using<\/p>\n<p>computer-based ERP systems, such as MaintainX.<\/p>\n<p>\uf0b7 Demonstrated history of a high level of safety leadership.<\/p>\n<p>\uf0b7 Proven experience in managing multiple priorities while maintaining a safe work culture and a zero<\/p>\n<p>tolerance for violation of Safety protocol.<\/p>\n<p><br><\/p><p>WORK ENVIRONMENT \/ CONDITIONS \/ PHYSICAL DEMANDS:<\/p>\n<p>These are considered essential duties and are illustrative of those job tasks, which are fundamental.<\/p>\n<p>Employees may be required to perform additional related duties as may be assigned by management.<\/p>\n<p>Reasonable accommodations may be made to enable individuals with disabilities to perform the essential<\/p>\n<p>functions.<\/p>\n<p>\uf0b7 Work will take place in various types of manufacturing environments as well as in outdoor settings.<\/p>\n<p>\uf0b7 Prolonged standing, climbing, pulling and lifting of heavy objects may be included in the job tasks.<\/p>\n<p>\uf0b7 Must be able to lift, pull and push at least 50lbs.<\/p>\n<p>\uf0b7 Will work on very uneven surfaces which will have rock and other debris in the area.<\/p>\n<p>\uf0b7 Must be able to wear required PPE to include steel-toed boots, safety glasses and hard hat always.<\/p>\n<p>\uf0b7 Must have a current valid driver\u2019s license.<\/p>","post_title":"Maintenance Supervisor","post_link":"https:\/\/turnerstaffing.com\/position\/maintenance-supervisor\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Senior","%location_country%":"United States","%location_city%":"Gabbs","%location_state_id%":"NV","%location_state_name%":"Nevada","%location_city_state%":"Gabbs, NV","%education%":"Unspecified","%department%":"","%description%":"<p>POSITION SUMMARY:<\/p>\n<p>Responsible for the safe operations and front-line leadership of the Upper Shop\/Fixed Equipment at the Gabbs<\/p>\n<p>mine location. This position is a critical leadership role which requires the ability to lead and maintain a solid<\/p>\n<p>safety and performance record. This role is part of the site Maintenance Leadership team and will need to<\/p>\n<p>represent all decisions and direction the team makes together. This role must be able to work collaboratively<\/p>\n<p>with others to include their team.<\/p>\n<p><br><\/p><p>ESSENTIAL DUTIES AND RESPONSIBILITIES:<\/p>\n<p>\uf0b7 Responsible for the direct, daily leadership of all Upper Shop\/Fixed Equipment personnel.<\/p>\n<p>\uf0b7 Support and participate in Company Asset Care Strategy initiative<\/p>\n<p>\uf0b7 Implement production plans according to the approved schedule.<\/p>\n<p>\uf0b7 Inspect and evaluate work in progress, identifies any problem areas, and directs remedial action.<\/p>\n<p>\uf0b7 Work closely with operations teams to assess priorities of scheduled and break in work<\/p>\n<p>\uf0b7 Always operate within MSHA standards and company safety policies and procedures.<\/p>\n<p>\uf0b7 Effectively lead and participate in short- and long-term strategic planning initiatives.<\/p>\n<p>\uf0b7 Spend significant time in the field \u2013 \u201cvisible felt leadership\u201d \u2013 interacting with the workforce ~60 - 80%<\/p>\n<p>of working time.<\/p>\n<p>\uf0b7 Provide employees with a safe and healthy work environment by ensuring the provision of safe systems<\/p>\n<p>of work; safe work procedures; adequate training and instruction; competent supervision.<\/p>\n<p>\uf0b7 Performs other duties as assigned.<\/p>\n<p><br><\/p><p>Required Experience<\/p>\n<p>\uf0b7 5+ years in a Maintenance Lead or Supervision level or higher experience in mining industry<\/p>\n<p>\uf0b7 2+ years in compiling and\/or managing maintenance budgets<\/p>\n<p>\uf0b7 2+ years management of the maintenance scheduling and workflow function<\/p>\n<p>\uf0b7 Experience managing or supervising an equipment reliability program<\/p>\n<p>\uf0b7 A strong safety record and the ability to work with a variety of individuals<\/p>\n<p>\uf0b7 Ability to adapt information and communication style to the audience<\/p>\n<p>\uf0b7 Skilled at promoting teamwork to establish consensus among team and stakeholders<\/p>\n<p>\uf0b7 Capable of identifying key issues and patterns in moderately complex situations and spotting new, less<\/p>\n<p>obvious solutions<\/p>\n<p><br><\/p><p>Required Skills<\/p>\n<p>\uf0b7 Knowledge and unwavering dedication to safety and health compliance and principles.<\/p>\n<p>\uf0b7 Strong knowledge of Surface mining operations including HSE, Maintenance and Operations.<\/p>\n<p>\uf0b7 Strong written, verbal and interpersonal communication skills.<\/p>\n<p>\uf0b7 Proficient in problem solving and strong analytical skills.<\/p>\n<p>\uf0b7 Strong ability to influence, persuade and motivate individuals or groups to achieve desired outcomes in<\/p>\n<p>a professional and morally ethical way.<\/p>\n<p>\uf0b7 Must be efficient in the use of MS Office products (Excel, Outlook and Word) with experience using<\/p>\n<p>computer-based ERP systems, such as MaintainX.<\/p>\n<p>\uf0b7 Demonstrated history of a high level of safety leadership.<\/p>\n<p>\uf0b7 Proven experience in managing multiple priorities while maintaining a safe work culture and a zero<\/p>\n<p>tolerance for violation of Safety protocol.<\/p>\n<p><br><\/p><p>WORK ENVIRONMENT \/ CONDITIONS \/ PHYSICAL DEMANDS:<\/p>\n<p>These are considered essential duties and are illustrative of those job tasks, which are fundamental.<\/p>\n<p>Employees may be required to perform additional related duties as may be assigned by management.<\/p>\n<p>Reasonable accommodations may be made to enable individuals with disabilities to perform the essential<\/p>\n<p>functions.<\/p>\n<p>\uf0b7 Work will take place in various types of manufacturing environments as well as in outdoor settings.<\/p>\n<p>\uf0b7 Prolonged standing, climbing, pulling and lifting of heavy objects may be included in the job tasks.<\/p>\n<p>\uf0b7 Must be able to lift, pull and push at least 50lbs.<\/p>\n<p>\uf0b7 Will work on very uneven surfaces which will have rock and other debris in the area.<\/p>\n<p>\uf0b7 Must be able to wear required PPE to include steel-toed boots, safety glasses and hard hat always.<\/p>\n<p>\uf0b7 Must have a current valid driver\u2019s license.<\/p>","%category%":"Management","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/8febb112c925-maintenance-supervisor","%breezy_id%":"8febb112c925","%breezy_friendly_id%":"8febb112c925-maintenance-supervisor","%breezy_created_date%":"2025-01-31T16:38:29.957Z","%breezy_updated_date%":"2025-01-31T16:40:13.267Z","%_wpgmp_location_city%":"Gabbs","%_wpgmp_location_state%":"NV","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Gabbs, NV, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"38.8690562","%_wpgmp_metabox_longitude%":"-117.9228819","%rank_math_internal_links_processed%":"1"}},"id":2127,"infowindow_disable":false},{"source":"post","title":"Project Scheduler","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Project Scheduler\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    We are seeking a highly organized project scheduler to implement and&nbsp;oversee project schedules. In this role, you will be collaborating&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/project-scheduler\/\" name=\"Project Scheduler\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"We are seeking a highly organized project scheduler to implement and&nbsp;oversee project schedules. In this role, you will be collaborating&hellip;","address":"Kershaw, SC, USA","location":{"lat":"34.5518201","city":"Kershaw","state":"SC","country":"United States","lng":"-80.5836836","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/project-scheduler\/","zoom":19,"extra_fields":{"post_excerpt":"We are seeking a highly organized project scheduler to implement and&nbsp;oversee project schedules. In this role, you will be collaborating&hellip;","post_content":"<p>We are seeking a highly organized project scheduler to implement and&nbsp;oversee project schedules. In this role, you will be collaborating with&nbsp;project personnel, setting tasks, and monitoring the execution of project&nbsp;timelines. You may also prepare project progress and performance&nbsp;evaluation reports.<\/p>\n<p>To ensure success, project schedulers should possess solid construction&nbsp;industry knowledge and demonstrable experience in project scheduling.&nbsp;A top-notch project scheduler will be someone whose expertise leads to&nbsp;the successful realization of envisaged project goals.<br><br><\/p>\n<p>Responsibilities:<br>\uf0b7Develop and manage comprehensive project schedules using tools&nbsp;such as Microsoft Project.<br>\uf0b7Coordinate with project managers, contractors, and other team&nbsp;members to gather necessary information for scheduling.<br>\uf0b7Monitor project progress and adjust schedules as needed to&nbsp;accommodate changes or delays.<br>\uf0b7Prepare regular reports on project status, highlighting any potential&nbsp;issues or risks that may impact timelines.<br>\uf0b7Ensure compliance with contract requirements and maintain accurate&nbsp;documentation related to scheduling.<br>\uf0b7Utilize time management skills to prioritize tasks effectively and meet&nbsp;deadlines.<br>\uf0b7Collaborate with construction management teams to ensure alignment&nbsp;between scheduling and project execution.<br><br><\/p>\n<p>Requirements:<br>\uf0b7Proven experience in project management or a related field,&nbsp;particularly within the construction industry.<br>\uf0b7Proficiency in construction management software such as Microsoft&nbsp;Project.<br>\uf0b7Strong understanding of contract specifications and the ability to interpret complex documents.<br>\uf0b7Excellent time management skills with the ability to handle multiple&nbsp;projects simultaneously.<br>\uf0b7Strong organizational skills and attention to detail.<br>\uf0b7Effective communication skills for collaboration with diverse teams and&nbsp;stakeholders.<br>\uf0b7A background in construction is preferred but not mandatory.<\/p>","post_title":"Project Scheduler","post_link":"https:\/\/turnerstaffing.com\/position\/project-scheduler\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Contract","%experience%":"","%location_country%":"United States","%location_city%":"Kershaw","%location_state_id%":"SC","%location_state_name%":"South Carolina","%location_city_state%":"Kershaw, SC","%education%":"","%department%":"","%description%":"<p>We are seeking a highly organized project scheduler to implement and&nbsp;oversee project schedules. In this role, you will be collaborating with&nbsp;project personnel, setting tasks, and monitoring the execution of project&nbsp;timelines. You may also prepare project progress and performance&nbsp;evaluation reports.<\/p>\n<p>To ensure success, project schedulers should possess solid construction&nbsp;industry knowledge and demonstrable experience in project scheduling.&nbsp;A top-notch project scheduler will be someone whose expertise leads to&nbsp;the successful realization of envisaged project goals.<br><br><\/p>\n<p>Responsibilities:<br>\uf0b7Develop and manage comprehensive project schedules using tools&nbsp;such as Microsoft Project.<br>\uf0b7Coordinate with project managers, contractors, and other team&nbsp;members to gather necessary information for scheduling.<br>\uf0b7Monitor project progress and adjust schedules as needed to&nbsp;accommodate changes or delays.<br>\uf0b7Prepare regular reports on project status, highlighting any potential&nbsp;issues or risks that may impact timelines.<br>\uf0b7Ensure compliance with contract requirements and maintain accurate&nbsp;documentation related to scheduling.<br>\uf0b7Utilize time management skills to prioritize tasks effectively and meet&nbsp;deadlines.<br>\uf0b7Collaborate with construction management teams to ensure alignment&nbsp;between scheduling and project execution.<br><br><\/p>\n<p>Requirements:<br>\uf0b7Proven experience in project management or a related field,&nbsp;particularly within the construction industry.<br>\uf0b7Proficiency in construction management software such as Microsoft&nbsp;Project.<br>\uf0b7Strong understanding of contract specifications and the ability to interpret complex documents.<br>\uf0b7Excellent time management skills with the ability to handle multiple&nbsp;projects simultaneously.<br>\uf0b7Strong organizational skills and attention to detail.<br>\uf0b7Effective communication skills for collaboration with diverse teams and&nbsp;stakeholders.<br>\uf0b7A background in construction is preferred but not mandatory.<\/p>","%category%":"","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/a6c32d606323-project-scheduler","%breezy_id%":"a6c32d606323","%breezy_friendly_id%":"a6c32d606323-project-scheduler","%breezy_created_date%":"2025-01-29T14:27:50.712Z","%breezy_updated_date%":"2025-01-29T16:16:24.492Z","%_wpgmp_location_city%":"Kershaw","%_wpgmp_location_state%":"SC","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Kershaw, SC, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"34.5518201","%_wpgmp_metabox_longitude%":"-80.5836836","%rank_math_internal_links_processed%":"1"}},"id":2126,"infowindow_disable":false},{"source":"post","title":"Asphalt Plant Superintendent","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Asphalt Plant Superintendent\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    We are seeking an experienced and dedicated Asphalt Plant Superintendent&nbsp;to oversee the day-to-day operations of our asphalt production facility. This&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/asphalt-plant-manager\/\" name=\"Asphalt Plant Superintendent\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"We are seeking an experienced and dedicated Asphalt Plant Superintendent&nbsp;to oversee the day-to-day operations of our asphalt production facility. This&hellip;","address":"Bend, OR, USA","location":{"lat":"44.0581728","city":"Bend","state":"OR","country":"United States","lng":"-121.3153096","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/asphalt-plant-manager\/","zoom":19,"extra_fields":{"post_excerpt":"We are seeking an experienced and dedicated Asphalt Plant Superintendent&nbsp;to oversee the day-to-day operations of our asphalt production facility. This&hellip;","post_content":"<p>We are seeking an experienced and dedicated Asphalt Plant Superintendent&nbsp;to oversee the day-to-day operations of our asphalt production facility. This role involves managing the production process, ensuring quality standards, maintaining safety regulations, and optimizing plant efficiency. The ideal candidate will have strong leadership skills, a solid understanding of asphalt production, and the ability to manage and mentor a team of 4-6 direct reports.&nbsp;<\/p>\n<p><strong>Key Responsibilities:<\/strong><br><\/p>\n<ul><li><strong>Production Management:<\/strong>&nbsp;Oversee the full operation of the asphalt plant, ensuring efficient and continuous production of high-quality asphalt.<\/li><li><strong>Team Leadership:<\/strong>&nbsp;Supervise and mentor a team of 4-6 direct reports, including operators, maintenance staff, and other personnel. Provide coaching, training, and performance feedback.<\/li><li><strong>Safety &amp; Compliance:<\/strong>&nbsp;Enforce plant safety protocols and ensure compliance with all local, state, and federal regulations, including environmental and safety standards.<\/li><li><strong>Maintenance &amp; Equipment Management:<\/strong>&nbsp;Coordinate routine maintenance and repairs to prevent downtime. Ensure that all plant equipment operates at peak efficiency and reliability.<\/li><li><strong>Quality Control:<\/strong>&nbsp;Implement and monitor quality control measures for the asphalt production process, ensuring that all products meet company and industry standards.<\/li><li><strong>Inventory &amp; Supply Management:<\/strong>&nbsp;Manage raw materials inventory, including ordering and storing materials as necessary to meet production schedules.<\/li><li><strong>Budget &amp; Cost Control:<\/strong>&nbsp;Assist in the preparation and monitoring of the plant\u2019s budget, identifying opportunities to reduce operational costs and improve efficiency.<\/li><li><strong>Reporting &amp; Documentation:<\/strong>&nbsp;Maintain accurate records of production, maintenance activities, and safety inspections. Prepare regular reports for upper management.<\/li><li><strong>Continuous Improvement:<\/strong>&nbsp;Identify opportunities for process optimization and drive continuous improvement initiatives within the plant.<\/li><\/ul>\n<p><strong>Required Skills &amp; Qualifications:<\/strong><br><\/p>\n<ul><li>Proven experience in asphalt plant operations, with at least 3-5 years in a supervisory role.<\/li><li>Strong understanding of asphalt production processes, equipment, and quality control procedures.<\/li><li>Excellent leadership and team management skills, with experience leading a small team of direct reports.<\/li><li>Strong problem-solving skills and the ability to make quick, effective decisions.<\/li><li>Solid understanding of safety standards and regulatory compliance, including OSHA and environmental regulations.<\/li><li>Effective communication skills with the ability to interact with both technical and non-technical personnel.<\/li><li>Ability to work in a fast-paced environment and manage multiple tasks simultaneously.<\/li><li>Proficiency in Microsoft Office Suite or similar software for reporting and documentation.<\/li><\/ul>\n<p><strong>Preferred Qualifications:<\/strong><br><\/p>\n<ul><li>Experience with plant automation systems and asphalt plant control software.<\/li><li>Knowledge of Lean Manufacturing principles or continuous improvement methodologies.<\/li><li>Certification in safety or environmental management.<\/li><\/ul>\n<p><strong>Benefits:<\/strong><br><\/p><p>PTO, Profit Sharing, 401k, Subsidized Health insurance, Relocation Assistance, Company vehicle, phone, laptop and iPad.<br><\/p>","post_title":"Asphalt Plant Superintendent","post_link":"https:\/\/turnerstaffing.com\/position\/asphalt-plant-manager\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"","%location_country%":"United States","%location_city%":"Bend","%location_state_id%":"OR","%location_state_name%":"Oregon","%location_city_state%":"Bend, OR","%education%":"","%department%":"","%description%":"<p>We are seeking an experienced and dedicated Asphalt Plant Superintendent&nbsp;to oversee the day-to-day operations of our asphalt production facility. This role involves managing the production process, ensuring quality standards, maintaining safety regulations, and optimizing plant efficiency. The ideal candidate will have strong leadership skills, a solid understanding of asphalt production, and the ability to manage and mentor a team of 4-6 direct reports.&nbsp;<\/p>\n<p><strong>Key Responsibilities:<\/strong><br><\/p>\n<ul><li><strong>Production Management:<\/strong>&nbsp;Oversee the full operation of the asphalt plant, ensuring efficient and continuous production of high-quality asphalt.<\/li><li><strong>Team Leadership:<\/strong>&nbsp;Supervise and mentor a team of 4-6 direct reports, including operators, maintenance staff, and other personnel. Provide coaching, training, and performance feedback.<\/li><li><strong>Safety &amp; Compliance:<\/strong>&nbsp;Enforce plant safety protocols and ensure compliance with all local, state, and federal regulations, including environmental and safety standards.<\/li><li><strong>Maintenance &amp; Equipment Management:<\/strong>&nbsp;Coordinate routine maintenance and repairs to prevent downtime. Ensure that all plant equipment operates at peak efficiency and reliability.<\/li><li><strong>Quality Control:<\/strong>&nbsp;Implement and monitor quality control measures for the asphalt production process, ensuring that all products meet company and industry standards.<\/li><li><strong>Inventory &amp; Supply Management:<\/strong>&nbsp;Manage raw materials inventory, including ordering and storing materials as necessary to meet production schedules.<\/li><li><strong>Budget &amp; Cost Control:<\/strong>&nbsp;Assist in the preparation and monitoring of the plant\u2019s budget, identifying opportunities to reduce operational costs and improve efficiency.<\/li><li><strong>Reporting &amp; Documentation:<\/strong>&nbsp;Maintain accurate records of production, maintenance activities, and safety inspections. Prepare regular reports for upper management.<\/li><li><strong>Continuous Improvement:<\/strong>&nbsp;Identify opportunities for process optimization and drive continuous improvement initiatives within the plant.<\/li><\/ul>\n<p><strong>Required Skills &amp; Qualifications:<\/strong><br><\/p>\n<ul><li>Proven experience in asphalt plant operations, with at least 3-5 years in a supervisory role.<\/li><li>Strong understanding of asphalt production processes, equipment, and quality control procedures.<\/li><li>Excellent leadership and team management skills, with experience leading a small team of direct reports.<\/li><li>Strong problem-solving skills and the ability to make quick, effective decisions.<\/li><li>Solid understanding of safety standards and regulatory compliance, including OSHA and environmental regulations.<\/li><li>Effective communication skills with the ability to interact with both technical and non-technical personnel.<\/li><li>Ability to work in a fast-paced environment and manage multiple tasks simultaneously.<\/li><li>Proficiency in Microsoft Office Suite or similar software for reporting and documentation.<\/li><\/ul>\n<p><strong>Preferred Qualifications:<\/strong><br><\/p>\n<ul><li>Experience with plant automation systems and asphalt plant control software.<\/li><li>Knowledge of Lean Manufacturing principles or continuous improvement methodologies.<\/li><li>Certification in safety or environmental management.<\/li><\/ul>\n<p><strong>Benefits:<\/strong><br><\/p><p>PTO, Profit Sharing, 401k, Subsidized Health insurance, Relocation Assistance, Company vehicle, phone, laptop and iPad.<br><\/p>","%category%":"","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/2e916aab9f84-asphalt-plant-superintendent","%breezy_id%":"2e916aab9f84","%breezy_friendly_id%":"2e916aab9f84-asphalt-plant-superintendent","%breezy_created_date%":"2025-01-28T21:40:45.044Z","%breezy_updated_date%":"2025-01-29T19:23:53.155Z","%_wpgmp_location_city%":"Bend","%_wpgmp_location_state%":"OR","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Bend, OR, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"44.0581728","%_wpgmp_metabox_longitude%":"-121.3153096","%rank_math_internal_links_processed%":"1"}},"id":2122,"infowindow_disable":false},{"source":"post","title":"Blade Operator","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Blade Operator\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Turner Mining Group \u2013 Heavy Equipment Operator Do you love mining? Do you think differently? Are you ready to define&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/blade-operator\/\" name=\"Blade Operator\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Turner Mining Group \u2013 Heavy Equipment Operator Do you love mining? Do you think differently? Are you ready to define&hellip;","address":"Kermit, TX, USA","location":{"lat":"31.8576265","city":"Kermit","state":"TX","country":"United States","lng":"-103.0926652","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/blade-operator\/","zoom":19,"extra_fields":{"post_excerpt":"Turner Mining Group \u2013 Heavy Equipment Operator Do you love mining? Do you think differently? Are you ready to define&hellip;","post_content":"<p><strong><u>Turner Mining Group \u2013 Heavy Equipment Operator<\/u><\/strong><\/p>\n<p>Do you love mining? Do you think differently? Are you ready to define the future of this industry?<\/p>\n<p>We\u2019ve been waiting for you! Turner Mining Group is committed to changing the way mining companies do business. We develop our people. We partner with our clients. We believe in win, win, win.<\/p>\n<p>We are looking for a dynamic and talented mining Heavy Equipment Operators for our fast-growing, forward thinking mining services company headquartered in Bloomington, Indiana with our Operations team headquartered in Salt Lake City, Utah.<\/p>\n<p>Turner Mining Group is seeking an energetic mining professionals who can leverage their mining knowledge to expand upon our fast-growing business, creating best practices for equipment operations to ensure profitable operations.<\/p>\n<p><strong>You<\/strong><\/p>\n<p>You want to work for a services company that is rapidly changing the way the largest materials producers do business. You are motivated by solving problems and partnering with our clients and suppliers. You want to work with great people and enjoy being a part of a strong team. You are a knowledgeable Operator who is not afraid to jump into every detail. You want to be in a place where continuous learning and growth is the norm. You are adaptable and able to juggle multiple initiatives concurrently.<\/p>\n<p><strong>Responsibilities:<\/strong><\/p>\n<ul><li>Operating heavy equipment including loaders, scrapers, blade, excavators, dozers, haul trucks, and other pieces of heavy equipment in a production environment<\/li><li>Performing all pre-shift inspections, some basic maintenance and upkeep<\/li><li>Working with teammates on crew to maximize production while always maintaining our safety rules and regulations.<\/li><\/ul>\n<p><strong>Requirements:<\/strong><\/p>\n<ul><li>Safety oriented, awareness of everyone and everything that is around you<\/li><li>Strong work ethic<\/li><li>Willingness to learn<\/li><li>Ability to be flexible and to adapt<\/li><li>Experience with heavy equipment<\/li><li>Preferred to have MSHA training<\/li><\/ul>\n<p><strong>Benefits:<\/strong><\/p>\n<p>Turner Mining Group offers a competitive salary, an excellent work culture, career advancement opportunities. Our team offers a benefits program which includes Medical, Dental, Vision, Life, and a 401k with company match.<\/p>\n<p>At Turner Mining Group, we encourage and celebrate an inclusive environment for all employees and are proud to be an equal opportunity workplace and affirmative action employer.<\/p>","post_title":"Blade Operator","post_link":"https:\/\/turnerstaffing.com\/position\/blade-operator\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Associate","%location_country%":"United States","%location_city%":"Kermit","%location_state_id%":"TX","%location_state_name%":"Texas","%location_city_state%":"Kermit, TX","%education%":"Unspecified","%department%":"Operations","%description%":"<p><strong><u>Turner Mining Group \u2013 Heavy Equipment Operator<\/u><\/strong><\/p>\n<p>Do you love mining? Do you think differently? Are you ready to define the future of this industry?<\/p>\n<p>We\u2019ve been waiting for you! Turner Mining Group is committed to changing the way mining companies do business. We develop our people. We partner with our clients. We believe in win, win, win.<\/p>\n<p>We are looking for a dynamic and talented mining Heavy Equipment Operators for our fast-growing, forward thinking mining services company headquartered in Bloomington, Indiana with our Operations team headquartered in Salt Lake City, Utah.<\/p>\n<p>Turner Mining Group is seeking an energetic mining professionals who can leverage their mining knowledge to expand upon our fast-growing business, creating best practices for equipment operations to ensure profitable operations.<\/p>\n<p><strong>You<\/strong><\/p>\n<p>You want to work for a services company that is rapidly changing the way the largest materials producers do business. You are motivated by solving problems and partnering with our clients and suppliers. You want to work with great people and enjoy being a part of a strong team. You are a knowledgeable Operator who is not afraid to jump into every detail. You want to be in a place where continuous learning and growth is the norm. You are adaptable and able to juggle multiple initiatives concurrently.<\/p>\n<p><strong>Responsibilities:<\/strong><\/p>\n<ul><li>Operating heavy equipment including loaders, scrapers, blade, excavators, dozers, haul trucks, and other pieces of heavy equipment in a production environment<\/li><li>Performing all pre-shift inspections, some basic maintenance and upkeep<\/li><li>Working with teammates on crew to maximize production while always maintaining our safety rules and regulations.<\/li><\/ul>\n<p><strong>Requirements:<\/strong><\/p>\n<ul><li>Safety oriented, awareness of everyone and everything that is around you<\/li><li>Strong work ethic<\/li><li>Willingness to learn<\/li><li>Ability to be flexible and to adapt<\/li><li>Experience with heavy equipment<\/li><li>Preferred to have MSHA training<\/li><\/ul>\n<p><strong>Benefits:<\/strong><\/p>\n<p>Turner Mining Group offers a competitive salary, an excellent work culture, career advancement opportunities. Our team offers a benefits program which includes Medical, Dental, Vision, Life, and a 401k with company match.<\/p>\n<p>At Turner Mining Group, we encourage and celebrate an inclusive environment for all employees and are proud to be an equal opportunity workplace and affirmative action employer.<\/p>","%category%":"Operations","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/5e3116ee9bb7-blade-operator","%breezy_id%":"5e3116ee9bb7","%breezy_friendly_id%":"5e3116ee9bb7-blade-operator","%breezy_created_date%":"2025-01-28T20:58:27.038Z","%breezy_updated_date%":"2025-02-12T18:06:03.889Z","%_wpgmp_location_city%":"Kermit","%_wpgmp_location_state%":"TX","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Kermit, TX, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"31.8576265","%_wpgmp_metabox_longitude%":"-103.0926652","%rank_math_internal_links_processed%":"1"}},"id":2121,"infowindow_disable":false},{"source":"post","title":"Turner Staffing Group Talent Network","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Turner Staffing Group Talent Network\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Turner Staffing Group is continuing to bring on new client and new opportunities for talent across the US! If you&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/turner-staffing-group-talent-network\/\" name=\"Turner Staffing Group Talent Network\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Turner Staffing Group is continuing to bring on new client and new opportunities for talent across the US! If you&hellip;","address":"Bloomington, IN, USA","location":{"lat":"39.169574","city":"Bloomington","state":"IN","country":"United States","lng":"-86.5385549","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/turner-staffing-group-talent-network\/","zoom":19,"extra_fields":{"post_excerpt":"Turner Staffing Group is continuing to bring on new client and new opportunities for talent across the US! If you&hellip;","post_content":"<p>Turner Staffing Group is continuing to bring on new client and new opportunities for talent across the US! If you are interested in the Turner Staffing Group team and would like to become a member of our talent network to be considered for future opportunities, we invite you to apply to this talent network application. We ask that you complete the candidate questionnaire as that information will help our team to target upcoming opportunities that might be a great fit for what you are looking for in your next career opportunity.<\/p>","post_title":"Turner Staffing Group Talent Network","post_link":"https:\/\/turnerstaffing.com\/position\/turner-staffing-group-talent-network\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Other","%experience%":"","%location_country%":"United States","%location_city%":"Bloomington","%location_state_id%":"IN","%location_state_name%":"Indiana","%location_city_state%":"Bloomington, IN","%education%":"","%department%":"","%description%":"<p>Turner Staffing Group is continuing to bring on new client and new opportunities for talent across the US! If you are interested in the Turner Staffing Group team and would like to become a member of our talent network to be considered for future opportunities, we invite you to apply to this talent network application. We ask that you complete the candidate questionnaire as that information will help our team to target upcoming opportunities that might be a great fit for what you are looking for in your next career opportunity.<\/p>","%category%":"","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/63fa9109724a-turner-staffing-group-talent-network","%breezy_id%":"63fa9109724a","%breezy_friendly_id%":"63fa9109724a-turner-staffing-group-talent-network","%breezy_created_date%":"2025-01-24T17:34:55.102Z","%breezy_updated_date%":"2025-02-20T14:58:16.430Z","%_wpgmp_location_city%":"Bloomington","%_wpgmp_location_state%":"IN","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Bloomington, IN, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"39.169574","%_wpgmp_metabox_longitude%":"-86.5385549","%rank_math_internal_links_processed%":"1"}},"id":2113,"infowindow_disable":false},{"source":"post","title":"Paving Superintendent","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Paving Superintendent\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Responsibilities We are looking for a hard-working, dedicated Paving Superintendent with high technical milling and paving knowledge and excellent leadership&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/paving-superintendent-2\/\" name=\"Paving Superintendent\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Responsibilities We are looking for a hard-working, dedicated Paving Superintendent with high technical milling and paving knowledge and excellent leadership&hellip;","address":"Richmond, VA, USA","location":{"lat":"37.5407246","city":"Richmond","state":"VA","country":"United States","lng":"-77.4360481","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/paving-superintendent-2\/","zoom":19,"extra_fields":{"post_excerpt":"Responsibilities We are looking for a hard-working, dedicated Paving Superintendent with high technical milling and paving knowledge and excellent leadership&hellip;","post_content":"<h2><strong>Responsibilities<\/strong><\/h2>\n<p>We are looking for a hard-working, dedicated Paving Superintendent with high technical milling and paving knowledge and excellent leadership skills. Join an elite team of professionals building exciting, innovative heavy civil projects.&nbsp;<\/p>\n<p><em>Responsibilities<\/em>:&nbsp;<\/p>\n<ul><li>Demonstrates technical proficiency in milling and paving operations.&nbsp;<\/li><li>Has a complete understanding of the plan details and specifications of assigned projects including the estimate, man-hour budget and production rates.&nbsp;&nbsp;<\/li><li>Plans and organizes work to maximize potential crew productivity. Establishes work plans and staffing plans for each phase of the project.&nbsp; Communicates performance expectations for productivity, quality, and safety to crews and monitors progress to ensure schedule and financial goals are met.&nbsp;<\/li><li>Supervises field managers for assigned projects and plans\/schedules manpower and equipment as needed. Mentors\/coaches field managers in leading their crews. Maximizes equipment utilization levels and schedules field personnel assignments.&nbsp;&nbsp;<\/li><li>Reviews job cost with Project Manager, Field Managers and implements adjustments as needed.&nbsp;&nbsp;&nbsp;<\/li><li>Coordinates and collaborates with Field Managers, other Superintendents, and the customer to implement successful project plans. Maintains professional relationships with the owner, engineer and other members of the construction team.&nbsp;&nbsp;<\/li><li>Inspects construction work as necessary to ensure quality requirements and standards are met.&nbsp;<\/li><li>Manages coordination with asphalt plants, trucking dispatchers, and MOT teams to ensure safety, profit, scheduling compliance and customer satisfaction.&nbsp;<\/li><\/ul>\n<ul><li>&nbsp;<\/li><\/ul>\n<h2><strong>Qualifications<\/strong><\/h2>\n<p>Qualifications:&nbsp;<\/p>\n<ul><li>High school diploma or equivalent (GED) required (equivalent work experience will be considered)&nbsp;<\/li><li>Bachelor\u2019s degree in Civil Engineering, Construction Management or related field preferred (continuing education in construction highly desirable)&nbsp;<\/li><li>Minimum 6 years of milling and paving experience with at least 2 years of Superintendent experience required&nbsp;<\/li><li>OSHA 30 hour certification required (those not having this credential must certify or be enrolled in a certification course within 6 months of hire\/promotion)&nbsp;<\/li><li>Valid driver\u2019s license required&nbsp;<\/li><\/ul>","post_title":"Paving Superintendent","post_link":"https:\/\/turnerstaffing.com\/position\/paving-superintendent-2\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"","%location_country%":"United States","%location_city%":"Richmond","%location_state_id%":"VA","%location_state_name%":"Virginia","%location_city_state%":"Richmond, VA","%education%":"","%department%":"","%description%":"<h2><strong>Responsibilities<\/strong><\/h2>\n<p>We are looking for a hard-working, dedicated Paving Superintendent with high technical milling and paving knowledge and excellent leadership skills. Join an elite team of professionals building exciting, innovative heavy civil projects.&nbsp;<\/p>\n<p><em>Responsibilities<\/em>:&nbsp;<\/p>\n<ul><li>Demonstrates technical proficiency in milling and paving operations.&nbsp;<\/li><li>Has a complete understanding of the plan details and specifications of assigned projects including the estimate, man-hour budget and production rates.&nbsp;&nbsp;<\/li><li>Plans and organizes work to maximize potential crew productivity. Establishes work plans and staffing plans for each phase of the project.&nbsp; Communicates performance expectations for productivity, quality, and safety to crews and monitors progress to ensure schedule and financial goals are met.&nbsp;<\/li><li>Supervises field managers for assigned projects and plans\/schedules manpower and equipment as needed. Mentors\/coaches field managers in leading their crews. Maximizes equipment utilization levels and schedules field personnel assignments.&nbsp;&nbsp;<\/li><li>Reviews job cost with Project Manager, Field Managers and implements adjustments as needed.&nbsp;&nbsp;&nbsp;<\/li><li>Coordinates and collaborates with Field Managers, other Superintendents, and the customer to implement successful project plans. Maintains professional relationships with the owner, engineer and other members of the construction team.&nbsp;&nbsp;<\/li><li>Inspects construction work as necessary to ensure quality requirements and standards are met.&nbsp;<\/li><li>Manages coordination with asphalt plants, trucking dispatchers, and MOT teams to ensure safety, profit, scheduling compliance and customer satisfaction.&nbsp;<\/li><\/ul>\n<ul><li>&nbsp;<\/li><\/ul>\n<h2><strong>Qualifications<\/strong><\/h2>\n<p>Qualifications:&nbsp;<\/p>\n<ul><li>High school diploma or equivalent (GED) required (equivalent work experience will be considered)&nbsp;<\/li><li>Bachelor\u2019s degree in Civil Engineering, Construction Management or related field preferred (continuing education in construction highly desirable)&nbsp;<\/li><li>Minimum 6 years of milling and paving experience with at least 2 years of Superintendent experience required&nbsp;<\/li><li>OSHA 30 hour certification required (those not having this credential must certify or be enrolled in a certification course within 6 months of hire\/promotion)&nbsp;<\/li><li>Valid driver\u2019s license required&nbsp;<\/li><\/ul>","%category%":"","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/8f7f240f7497-paving-superintendent","%breezy_id%":"8f7f240f7497","%breezy_friendly_id%":"8f7f240f7497-paving-superintendent","%breezy_created_date%":"2024-06-06T13:50:44.340Z","%breezy_updated_date%":"2025-02-04T16:39:19.722Z","%_wpgmp_location_city%":"Richmond","%_wpgmp_location_state%":"VA","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Richmond, VA, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"37.5407246","%_wpgmp_metabox_longitude%":"-77.4360481","%rank_math_internal_links_processed%":"1"}},"id":2112,"infowindow_disable":false},{"source":"post","title":"Paving Superintendent","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Paving Superintendent\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Responsibilities: We are looking for a hard-working, dedicated Paving Superintendent with high technical milling and paving knowledge and excellent leadership&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/paving-superintendent\/\" name=\"Paving Superintendent\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Responsibilities: We are looking for a hard-working, dedicated Paving Superintendent with high technical milling and paving knowledge and excellent leadership&hellip;","address":"Fairfax, VA, USA","location":{"lat":"38.8459879","city":"Fairfax","state":"VA","country":"United States","lng":"-77.3053035","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/paving-superintendent\/","zoom":19,"extra_fields":{"post_excerpt":"Responsibilities: We are looking for a hard-working, dedicated Paving Superintendent with high technical milling and paving knowledge and excellent leadership&hellip;","post_content":"<p>Responsibilities:<\/p>\n<p>We are looking for a hard-working, dedicated Paving Superintendent with high technical milling and paving knowledge and excellent leadership skills to join our client in the Northern Virginia\/Baltimore, MD area. Join our elite team of professionals building exciting, innovative heavy civil projects. You will find coworkers who are ready to collaborate and commit to working better, faster, and safer on the job. We build things that matter while providing a pathway to the American Dream. Join us and let's build excellence together.<\/p>\n<p>Responsibilities:<\/p>\n<p>- Demonstrates technical proficiency in milling and paving operations.<\/p>\n<p>- Has a complete understanding of the plan details and specifications of assigned projects including the estimate, man-hour <\/p>\n<p>    budget and production rates.<\/p>\n<p>- Plans and organizes work to maximize potential crew productivity. Establishes work plans and staffing plans for each <\/p>\n<p>   phase of the project. Communicates performance expectations for productivity, quality, and safety to crews and monitors <\/p>\n<p>   progress to ensure schedule and financial goals are met.<\/p>\n<p>- Supervises field managers for assigned projects and plans\/schedules manpower and equipment as needed.<\/p>\n<p>- Mentors\/coaches field managers in leading their crews. Maximizes equipment utilization levels and schedules field <\/p>\n<p>    personnel assignments.<\/p>\n<p>- Reviews job cost with Project Manager, Field Managers and implements adjustments as needed.<\/p>\n<p>- Follows our client's&nbsp;Safety Program including preplanning to identify conditions and exposures, proper safety and <\/p>\n<p>    personal protective equipment and accident investigation and reporting.<\/p>\n<p>- Coordinates and collaborates with Field Managers, other Superintendents, and the customer to implement successful <\/p>\n<p>    project plans. Maintains professional relationships with the owner, engineer and other members of the construction team.<\/p>\n<p>- Inspects construction work as necessary to ensure quality requirements and standards are met.<\/p>\n<p>- Manages coordination with asphalt plants, trucking dispatchers, and MOT teams to ensure safety, profit, scheduling <\/p>\n<p>   compliance and customer satisfaction.<\/p>\n<p>Qualifications:<\/p>\n<p>- High school diploma or equivalent (GED) required (equivalent work experience will be considered)<\/p>\n<p>- Bachelor\u2019s degree in Civil Engineering, Construction Management or related field preferred (continuing education in <\/p>\n<p>    construction highly desirable)<\/p>\n<p>- Minimum 6 years of milling and paving experience with at least 2 years of Superintendent experience required<\/p>\n<p>    OSHA 30 hour certification required (those not having this credential must certify or be enrolled in a certification course <\/p>\n<p>    within 6 months of hire\/promotion)<\/p>\n<p>- Valid driver\u2019s license required<\/p>","post_title":"Paving Superintendent","post_link":"https:\/\/turnerstaffing.com\/position\/paving-superintendent\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Mid Level","%location_country%":"United States","%location_city%":"Fairfax","%location_state_id%":"VA","%location_state_name%":"Virginia","%location_city_state%":"Fairfax, VA","%education%":"High School or equivalent","%department%":"Operations","%description%":"<p>Responsibilities:<\/p>\n<p>We are looking for a hard-working, dedicated Paving Superintendent with high technical milling and paving knowledge and excellent leadership skills to join our client in the Northern Virginia\/Baltimore, MD area. Join our elite team of professionals building exciting, innovative heavy civil projects. You will find coworkers who are ready to collaborate and commit to working better, faster, and safer on the job. We build things that matter while providing a pathway to the American Dream. Join us and let's build excellence together.<\/p>\n<p>Responsibilities:<\/p>\n<p>- Demonstrates technical proficiency in milling and paving operations.<\/p>\n<p>- Has a complete understanding of the plan details and specifications of assigned projects including the estimate, man-hour <\/p>\n<p>    budget and production rates.<\/p>\n<p>- Plans and organizes work to maximize potential crew productivity. Establishes work plans and staffing plans for each <\/p>\n<p>   phase of the project. Communicates performance expectations for productivity, quality, and safety to crews and monitors <\/p>\n<p>   progress to ensure schedule and financial goals are met.<\/p>\n<p>- Supervises field managers for assigned projects and plans\/schedules manpower and equipment as needed.<\/p>\n<p>- Mentors\/coaches field managers in leading their crews. Maximizes equipment utilization levels and schedules field <\/p>\n<p>    personnel assignments.<\/p>\n<p>- Reviews job cost with Project Manager, Field Managers and implements adjustments as needed.<\/p>\n<p>- Follows our client's&nbsp;Safety Program including preplanning to identify conditions and exposures, proper safety and <\/p>\n<p>    personal protective equipment and accident investigation and reporting.<\/p>\n<p>- Coordinates and collaborates with Field Managers, other Superintendents, and the customer to implement successful <\/p>\n<p>    project plans. Maintains professional relationships with the owner, engineer and other members of the construction team.<\/p>\n<p>- Inspects construction work as necessary to ensure quality requirements and standards are met.<\/p>\n<p>- Manages coordination with asphalt plants, trucking dispatchers, and MOT teams to ensure safety, profit, scheduling <\/p>\n<p>   compliance and customer satisfaction.<\/p>\n<p>Qualifications:<\/p>\n<p>- High school diploma or equivalent (GED) required (equivalent work experience will be considered)<\/p>\n<p>- Bachelor\u2019s degree in Civil Engineering, Construction Management or related field preferred (continuing education in <\/p>\n<p>    construction highly desirable)<\/p>\n<p>- Minimum 6 years of milling and paving experience with at least 2 years of Superintendent experience required<\/p>\n<p>    OSHA 30 hour certification required (those not having this credential must certify or be enrolled in a certification course <\/p>\n<p>    within 6 months of hire\/promotion)<\/p>\n<p>- Valid driver\u2019s license required<\/p>","%category%":"Operations","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/a298f15759e4-paving-superintendent","%breezy_id%":"a298f15759e4","%breezy_friendly_id%":"a298f15759e4-paving-superintendent","%breezy_created_date%":"2024-01-30T15:02:33.844Z","%breezy_updated_date%":"2025-02-11T14:33:51.792Z","%_wpgmp_location_city%":"Fairfax","%_wpgmp_location_state%":"VA","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Fairfax, VA, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"38.8459879","%_wpgmp_metabox_longitude%":"-77.3053035","%rank_math_internal_links_processed%":"1"}},"id":2111,"infowindow_disable":false},{"source":"post","title":"Electrician","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Electrician\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    We are seeking a skilled and experienced Electrician to join our team for a project-based position at a mine site&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/electrician\/\" name=\"Electrician\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"We are seeking a skilled and experienced Electrician to join our team for a project-based position at a mine site&hellip;","address":"Elko, NV, USA","location":{"lat":"40.8436459","city":"Elko","state":"NV","country":"United States","lng":"-115.7526187","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/electrician\/","zoom":19,"extra_fields":{"post_excerpt":"We are seeking a skilled and experienced Electrician to join our team for a project-based position at a mine site&hellip;","post_content":"<p>We are seeking a skilled and experienced Electrician to join our team for a project-based position at a mine site in the Elko, Nevada area. The successful candidate will be responsible for pulling cables and fiber, terminating into junction boxes and programmable logic controllers (PLCs), and ensuring the efficient and safe operation of electrical systems on-site.<\/p>\n<p><strong>Responsibilities:<\/strong><\/p>\n<ul><li>Pull and terminate cables and fiber into junction boxes and PLCs.<\/li><li>Work with a variety of voltages, ranging from 120V to 480V.<\/li><li>Perform electrical testing and troubleshoot as needed.<\/li><li>Utilize electrical meters to ensure systems are functioning correctly.<\/li><li>Operate manlifts to work at heights (on decks or in baskets) as required.<\/li><li>Follow all safety guidelines and regulations to ensure a safe work environment.<\/li><li>Work as part of a team to complete tasks in a timely and efficient manner.<\/li><\/ul>\n<p><strong>Qualifications:<\/strong><\/p>\n<ul><li>Proven experience as an electrician, specifically in industrial or mining environments.<\/li><li>Experience working with electrical systems from 120V to 480V.<\/li><li>Comfort and ability to work off a manlift at heights.<\/li><li>Proficient in using electrical meters for testing and troubleshooting.<\/li><li>Strong attention to detail with a focus on safety and quality of work.<\/li><li>Ability to work independently and as part of a team in a fast-paced environment.<\/li><li>Must be available to work Monday through Friday, 12 hours\/day, for the duration of the project (February through June).<\/li><li>Must be authorized to work in the US without work visa sponsorship<\/li><\/ul>\n<p><strong>Preferred:<\/strong><\/p>\n<ul><li>Previous mine site experience is a plus.<\/li><li>Ability to work in harsh or remote environments.<\/li><\/ul>","post_title":"Electrician","post_link":"https:\/\/turnerstaffing.com\/position\/electrician\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"","%location_country%":"United States","%location_city%":"Elko","%location_state_id%":"NV","%location_state_name%":"Nevada","%location_city_state%":"Elko, NV","%education%":"","%department%":"","%description%":"<p>We are seeking a skilled and experienced Electrician to join our team for a project-based position at a mine site in the Elko, Nevada area. The successful candidate will be responsible for pulling cables and fiber, terminating into junction boxes and programmable logic controllers (PLCs), and ensuring the efficient and safe operation of electrical systems on-site.<\/p>\n<p><strong>Responsibilities:<\/strong><\/p>\n<ul><li>Pull and terminate cables and fiber into junction boxes and PLCs.<\/li><li>Work with a variety of voltages, ranging from 120V to 480V.<\/li><li>Perform electrical testing and troubleshoot as needed.<\/li><li>Utilize electrical meters to ensure systems are functioning correctly.<\/li><li>Operate manlifts to work at heights (on decks or in baskets) as required.<\/li><li>Follow all safety guidelines and regulations to ensure a safe work environment.<\/li><li>Work as part of a team to complete tasks in a timely and efficient manner.<\/li><\/ul>\n<p><strong>Qualifications:<\/strong><\/p>\n<ul><li>Proven experience as an electrician, specifically in industrial or mining environments.<\/li><li>Experience working with electrical systems from 120V to 480V.<\/li><li>Comfort and ability to work off a manlift at heights.<\/li><li>Proficient in using electrical meters for testing and troubleshooting.<\/li><li>Strong attention to detail with a focus on safety and quality of work.<\/li><li>Ability to work independently and as part of a team in a fast-paced environment.<\/li><li>Must be available to work Monday through Friday, 12 hours\/day, for the duration of the project (February through June).<\/li><li>Must be authorized to work in the US without work visa sponsorship<\/li><\/ul>\n<p><strong>Preferred:<\/strong><\/p>\n<ul><li>Previous mine site experience is a plus.<\/li><li>Ability to work in harsh or remote environments.<\/li><\/ul>","%category%":"","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/8fecdb31d7eb-electrician","%breezy_id%":"8fecdb31d7eb","%breezy_friendly_id%":"8fecdb31d7eb-electrician","%breezy_created_date%":"2025-01-14T00:13:20.517Z","%breezy_updated_date%":"2025-01-30T17:36:00.656Z","%_wpgmp_location_city%":"Elko","%_wpgmp_location_state%":"NV","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Elko, NV, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"40.8436459","%_wpgmp_metabox_longitude%":"-115.7526187","%rank_math_internal_links_processed%":"1"}},"id":2092,"infowindow_disable":false},{"source":"post","title":"Haul Truck Driver","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Haul Truck Driver\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Turner Mining Group \u2013 Haul Truck Driver Do you love mining? Do you think differently? Are you ready to define&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/haul-truck-driver\/\" name=\"Haul Truck Driver\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Turner Mining Group \u2013 Haul Truck Driver Do you love mining? Do you think differently? Are you ready to define&hellip;","address":"Kingman, AZ, USA","location":{"lat":"35.1912977","city":"Kingman","state":"AZ","country":"United States","lng":"-114.0522845","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/haul-truck-driver\/","zoom":19,"extra_fields":{"post_excerpt":"Turner Mining Group \u2013 Haul Truck Driver Do you love mining? Do you think differently? Are you ready to define&hellip;","post_content":"<p style=\"color:#555555\"><strong><span style=\"text-decoration:underline\"><span style=\"color:#555555\">Turner Mining Group \u2013 Haul Truck Driver<\/span><\/span><\/strong><\/p>\n<p style=\"color:#000000\"><span style=\"color:#333333\">Do you love mining? Do you think differently? Are you ready to define the future of this industry?<\/span><\/p>\n<p style=\"color:#000000\"><span style=\"color:#333333\">We\u2019ve been waiting for you! Turner Mining Group is committed to changing the way mining companies do business. We develop our people. We partner with our clients. We believe in win, win, win.<\/span><\/p>\n<p style=\"color:#000000\"><span style=\"color:#333333\">We are looking for a dynamic and talented mining Haul Truck Drivers for our fast-growing, forward thinking mining services company headquartered in Bloomington, Indiana with our Operations team headquartered in Salt Lake City, Utah.<\/span><\/p>\n<p style=\"color:#000000\"><span style=\"color:#333333\">Turner Mining Group is seeking an energetic mining professionals who can leverage their mining knowledge to expand upon our fast-growing business, creating best practices for equipment operations to ensure profitable operations.<\/span><\/p>\n<p style=\"color:#000000\"><span style=\"color:#555555\">If you would like to get involved and make a large contribution in mining or minerals processing, then you may enjoy a position as Haul Truck Driver. This position is great for anyone who would like to begin a career in mining, has experience in a related industry but would like to learn about mining, or has experience as a miner but would like to grow into further positions with Turner Mining Group.<\/span><\/p>\n<p style=\"color:#000000\"><strong><span style=\"color:#333333\">You<\/span><\/strong><\/p>\n<p style=\"color:#000000\"><span style=\"color:#333333\">You want to work for a services company that is rapidly changing the way the largest materials producers do business. You are motivated by solving problems and partnering with our clients and suppliers. You want to work with great people and enjoy being a part of a strong team. You are a knowledgeable Operator who is not afraid to jump into every detail. You want to be in a place where continuous learning and growth is the norm. You are adaptable and able to juggle multiple initiatives concurrently.<\/span><\/p>\n<p style=\"color:#000000\"><strong><span style=\"color:#555555\">Responsibilities:<\/span><\/strong><\/p>\n<ul><li><span style=\"color:#555555\">Operate and drive heavy haul trucks to transport tons of materials over short distances in a surface environment.<\/span><\/li><li><span style=\"color:#555555\">Perform inspections of vehicle systems, equipment and accessories such as tires, lights, turn signals and brakes<\/span><\/li><li><span style=\"color:#555555\">Ensure cargo is properly loaded according to safety requirements<\/span><\/li><li><span style=\"color:#555555\">Follow all safety policies, procedures and legislation<\/span><\/li><li><span style=\"color:#555555\">Maintain paper or electronic log book<\/span><\/li><li><span style=\"color:#555555\">Communicate with Dispatcher and other Haul Truck Drivers using communication devices such as a two-ways radio or onboard computers<\/span><\/li><li><span style=\"color:#555555\">May drive special purpose vehicles, including: end dump trucks, center dump truck units and water trucks<\/span><\/li><\/ul>\n<p style=\"color:#000000\"><strong><span style=\"color:#333333\">Requirements:<\/span><\/strong><\/p>\n<ul><li><span style=\"color:#555555\">Safety oriented, awareness of everyone and everything that is around you<\/span><\/li><li><span style=\"color:#555555\">Strong work ethic<\/span><\/li><li><span style=\"color:#555555\">Willingness to learn<\/span><\/li><li><span style=\"color:#555555\">Ability to be flexible and to adapt<\/span><\/li><li><span style=\"color:#555555\">Experience with heavy equipment<\/span><\/li><li><span style=\"color:#555555\">Preferred to have MSHA training<\/span><\/li><\/ul>\n<p style=\"color:#000000\"><strong><span style=\"color:#333333\">Benefits:<\/span><\/strong><\/p>\n<p style=\"color:#000000\"><span style=\"color:#333333\">Turner Mining Group offers a competitive salary, an excellent work culture, career advancement opportunities. Our team offers a benefits program which includes Medical, Dental, Vision, Life, and a 401k with company match.<\/span><\/p>\n<p style=\"color:#000000\"><span style=\"color:#333333\">At Turner Mining Group, we encourage and celebrate an inclusive environment for all employees and are proud to be an equal opportunity workplace and affirmative action employer.<\/span><\/p>\n<p style=\"color:#000000\">&nbsp;<\/p>\n<p style=\"color:#000000\">&nbsp;<\/p>\n<p style=\"color:#555555\"><br><\/p>\n<p style=\"color:#000000\"><span style=\"color:#333333\"><\/span><br><\/p>","post_title":"Haul Truck Driver","post_link":"https:\/\/turnerstaffing.com\/position\/haul-truck-driver\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"","%location_country%":"United States","%location_city%":"Kingman","%location_state_id%":"AZ","%location_state_name%":"Arizona","%location_city_state%":"Kingman, AZ","%education%":"","%department%":"Construction","%description%":"<p style=\"color:#555555;\"><strong><span style=\"text-decoration:underline;\"><span style=\"color:#555555;\">Turner Mining Group \u2013 Haul Truck Driver<\/span><\/span><\/strong><\/p>\n<p style=\"color:#000000;\"><span style=\"color:#333333;\">Do you love mining? Do you think differently? Are you ready to define the future of this industry?<\/span><\/p>\n<p style=\"color:#000000;\"><span style=\"color:#333333;\">We\u2019ve been waiting for you! Turner Mining Group is committed to changing the way mining companies do business. We develop our people. We partner with our clients. We believe in win, win, win.<\/span><\/p>\n<p style=\"color:#000000;\"><span style=\"color:#333333;\">We are looking for a dynamic and talented mining Haul Truck Drivers for our fast-growing, forward thinking mining services company headquartered in Bloomington, Indiana with our Operations team headquartered in Salt Lake City, Utah.<\/span><\/p>\n<p style=\"color:#000000;\"><span style=\"color:#333333;\">Turner Mining Group is seeking an energetic mining professionals who can leverage their mining knowledge to expand upon our fast-growing business, creating best practices for equipment operations to ensure profitable operations.<\/span><\/p>\n<p style=\"color:#000000;\"><span style=\"color:#555555;\">If you would like to get involved and make a large contribution in mining or minerals processing, then you may enjoy a position as Haul Truck Driver. This position is great for anyone who would like to begin a career in mining, has experience in a related industry but would like to learn about mining, or has experience as a miner but would like to grow into further positions with Turner Mining Group.<\/span><\/p>\n<p style=\"color:#000000;\"><strong><span style=\"color:#333333;\">You<\/span><\/strong><\/p>\n<p style=\"color:#000000;\"><span style=\"color:#333333;\">You want to work for a services company that is rapidly changing the way the largest materials producers do business. You are motivated by solving problems and partnering with our clients and suppliers. You want to work with great people and enjoy being a part of a strong team. You are a knowledgeable Operator who is not afraid to jump into every detail. You want to be in a place where continuous learning and growth is the norm. You are adaptable and able to juggle multiple initiatives concurrently.<\/span><\/p>\n<p style=\"color:#000000;\"><strong><span style=\"color:#555555;\">Responsibilities:<\/span><\/strong><\/p>\n<ul><li><span style=\"color:#555555;\">Operate and drive heavy haul trucks to transport tons of materials over short distances in a surface environment.<\/span><\/li><li><span style=\"color:#555555;\">Perform inspections of vehicle systems, equipment and accessories such as tires, lights, turn signals and brakes<\/span><\/li><li><span style=\"color:#555555;\">Ensure cargo is properly loaded according to safety requirements<\/span><\/li><li><span style=\"color:#555555;\">Follow all safety policies, procedures and legislation<\/span><\/li><li><span style=\"color:#555555;\">Maintain paper or electronic log book<\/span><\/li><li><span style=\"color:#555555;\">Communicate with Dispatcher and other Haul Truck Drivers using communication devices such as a two-ways radio or onboard computers<\/span><\/li><li><span style=\"color:#555555;\">May drive special purpose vehicles, including: end dump trucks, center dump truck units and water trucks<\/span><\/li><\/ul>\n<p style=\"color:#000000;\"><strong><span style=\"color:#333333;\">Requirements:<\/span><\/strong><\/p>\n<ul><li><span style=\"color:#555555;\">Safety oriented, awareness of everyone and everything that is around you<\/span><\/li><li><span style=\"color:#555555;\">Strong work ethic<\/span><\/li><li><span style=\"color:#555555;\">Willingness to learn<\/span><\/li><li><span style=\"color:#555555;\">Ability to be flexible and to adapt<\/span><\/li><li><span style=\"color:#555555;\">Experience with heavy equipment<\/span><\/li><li><span style=\"color:#555555;\">Preferred to have MSHA training<\/span><\/li><\/ul>\n<p style=\"color:#000000;\"><strong><span style=\"color:#333333;\">Benefits:<\/span><\/strong><\/p>\n<p style=\"color:#000000;\"><span style=\"color:#333333;\">Turner Mining Group offers a competitive salary, an excellent work culture, career advancement opportunities. Our team offers a benefits program which includes Medical, Dental, Vision, Life, and a 401k with company match.<\/span><\/p>\n<p style=\"color:#000000;\"><span style=\"color:#333333;\">At Turner Mining Group, we encourage and celebrate an inclusive environment for all employees and are proud to be an equal opportunity workplace and affirmative action employer.<\/span><\/p>\n<p style=\"color:#000000;\">&nbsp;<\/p>\n<p style=\"color:#000000;\">&nbsp;<\/p>\n<p style=\"color:#555555;\"><br><\/p>\n<p style=\"color:#000000;\"><span style=\"color:#333333;\"><\/span><br><\/p>","%category%":"Operations","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/47d9f8dffb11-haul-truck-driver","%breezy_id%":"47d9f8dffb11","%breezy_friendly_id%":"47d9f8dffb11-haul-truck-driver","%breezy_created_date%":"2021-11-16T20:55:19.000Z","%breezy_updated_date%":"2025-02-18T15:07:11.061Z","%_wpgmp_location_city%":"Kingman","%_wpgmp_location_state%":"AZ","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Kingman, AZ, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"35.1912977","%_wpgmp_metabox_longitude%":"-114.0522845","%rank_math_internal_links_processed%":"1"}},"id":2091,"infowindow_disable":false},{"source":"post","title":"Underground Drill Mechanic","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Underground Drill Mechanic\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Mechanic I-IV Do you want to work with the best people and equipment in the industry? Are you tired of&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/underground-drill-mechanic\/\" name=\"Underground Drill Mechanic\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Mechanic I-IV Do you want to work with the best people and equipment in the industry? Are you tired of&hellip;","address":"Elko, NV, USA","location":{"lat":"40.8436459","city":"Elko","state":"NV","country":"United States","lng":"-115.7526187","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/underground-drill-mechanic\/","zoom":19,"extra_fields":{"post_excerpt":"Mechanic I-IV Do you want to work with the best people and equipment in the industry? Are you tired of&hellip;","post_content":"<p><strong>Mechanic I-IV<\/strong><\/p>\n<p>Do you want to work with the best people and equipment in the industry? Are you tired of not having the parts and support needed to do your job? We offer clean, modern workspaces, fully stocked parts rooms, advanced repair and fabrication equipment, and knowledgeable, supportive leadership that will help you progress in your career.<\/p>\n<p>Our greatest asset is our team of hardworking professionals \u2013 especially our reliable and experienced maintenance crews. If you value integrity, an honest day\u2019s work, and professionalism, you will feel right at home.<\/p>\n<p>In addition to respect and appreciation for a job well done, we offer industry-leading equipment, monthly tooling allowance, competitive compensation, and travel per diem paired with a comprehensive Employee Benefit Program, including things like company-paid insurance premiums (where we pay 100% of the employee-only insurance premiums), 401(k) match, and paid time off.<\/p>\n<p>Position Overview<\/p>\n<p>We are currently hiring experienced, full-time, hourly shop and field mechanics. These positions diagnose, adjust, repair, fabricate, and overhaul mobile mechanical, hydraulic, and pneumatic parts, and equipment\/vehicles. Excellent welding and fabricating experience preferred.<\/p>\n<ul><li>For field mechanics, travel is required.<\/li><li>Mechanics can work a 10 days on\/4 days off, or 9 days on\/5 days off schedule.<\/li><\/ul>\n<p>Essential Functions<\/p>\n<ul><li>Demonstrate a strong commitment to safe work practices and procedures.<\/li><li>Repair and replace damaged or worn parts.<\/li><li>Operate and inspect machines or heavy equipment to diagnose defects.<\/li><li>Diagnose faults or malfunctions to determine required repairs, using engine diagnostic equipment such as computerized test equipment and calibration devices.<\/li><li>Dismantle and reassemble heavy equipment using hoists and hand tools.<\/li><li>Clean, lubricate, and perform other routine maintenance work on equipment and vehicles.<\/li><li>Examine parts for damage or excessive wear using micrometers and gauges.<\/li><li>Schedule maintenance for industrial machines and equipment and keep equipment service records.<\/li><li>Read and understand operating manuals, blueprints, and technical drawings.<\/li><li>Weld or solder broken parts and structural members using electric or gas welders and soldering tools.<\/li><li>Fabricate needed parts or items as required.<\/li><li>Exhibit a strong work ethic with the drive and desire to learn and perform tasks efficiently.<\/li><li>Maintain effective and collaborative workplace relationships, treating others with dignity and respect.<\/li><\/ul>\n<p>Qualifications<\/p>\n<ul><li>Must pass a pre-employment physical, drug (including the use of marijuana) and alcohol screening, Motor Vehicle Report (MVR), and additional background screening as required by regulation and\/or industry practice.<\/li><li>Must have a valid driver's license.<\/li><li>Must be willing to travel and work in remote locations, outside, and in all weather conditions (heat and cold)<\/li><li>Experience repairing and maintaining underground drill&nbsp;equipment (U6 and U8).<\/li><li>Experience running, maneuvering, navigating, or driving vehicles or mechanized equipment, such as forklifts, passenger and heavy equipment, and vehicles.<\/li><li>Experience analyzing information and evaluating results to choose the best solution and solve problems.<\/li><li>Experience inspecting equipment, structures, or materials to identify the cause of errors or other problems or defects.<\/li><li>Ability to understand and carry out general instructions in standard situations.<\/li><li>Ability to make decisions with a general understanding of procedures and company policies to achieve set results and deadlines.<\/li><li>Ability to multi-task and work under aggressive deadline pressure.<\/li><li>Ability to maintain a positive outlook when challenged with difficult or unknown problems.<\/li><li>Possess good time management skills.<\/li><\/ul>","post_title":"Underground Drill Mechanic","post_link":"https:\/\/turnerstaffing.com\/position\/underground-drill-mechanic\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Mid Level","%location_country%":"United States","%location_city%":"Elko","%location_state_id%":"NV","%location_state_name%":"Nevada","%location_city_state%":"Elko, NV","%education%":"Unspecified","%department%":"","%description%":"<p><strong>Mechanic I-IV<\/strong><\/p>\n<p>Do you want to work with the best people and equipment in the industry? Are you tired of not having the parts and support needed to do your job? We offer clean, modern workspaces, fully stocked parts rooms, advanced repair and fabrication equipment, and knowledgeable, supportive leadership that will help you progress in your career.<\/p>\n<p>Our greatest asset is our team of hardworking professionals \u2013 especially our reliable and experienced maintenance crews. If you value integrity, an honest day\u2019s work, and professionalism, you will feel right at home.<\/p>\n<p>In addition to respect and appreciation for a job well done, we offer industry-leading equipment, monthly tooling allowance, competitive compensation, and travel per diem paired with a comprehensive Employee Benefit Program, including things like company-paid insurance premiums (where we pay 100% of the employee-only insurance premiums), 401(k) match, and paid time off.<\/p>\n<p>Position Overview<\/p>\n<p>We are currently hiring experienced, full-time, hourly shop and field mechanics. These positions diagnose, adjust, repair, fabricate, and overhaul mobile mechanical, hydraulic, and pneumatic parts, and equipment\/vehicles. Excellent welding and fabricating experience preferred.<\/p>\n<ul><li>For field mechanics, travel is required.<\/li><li>Mechanics can work a 10 days on\/4 days off, or 9 days on\/5 days off schedule.<\/li><\/ul>\n<p>Essential Functions<\/p>\n<ul><li>Demonstrate a strong commitment to safe work practices and procedures.<\/li><li>Repair and replace damaged or worn parts.<\/li><li>Operate and inspect machines or heavy equipment to diagnose defects.<\/li><li>Diagnose faults or malfunctions to determine required repairs, using engine diagnostic equipment such as computerized test equipment and calibration devices.<\/li><li>Dismantle and reassemble heavy equipment using hoists and hand tools.<\/li><li>Clean, lubricate, and perform other routine maintenance work on equipment and vehicles.<\/li><li>Examine parts for damage or excessive wear using micrometers and gauges.<\/li><li>Schedule maintenance for industrial machines and equipment and keep equipment service records.<\/li><li>Read and understand operating manuals, blueprints, and technical drawings.<\/li><li>Weld or solder broken parts and structural members using electric or gas welders and soldering tools.<\/li><li>Fabricate needed parts or items as required.<\/li><li>Exhibit a strong work ethic with the drive and desire to learn and perform tasks efficiently.<\/li><li>Maintain effective and collaborative workplace relationships, treating others with dignity and respect.<\/li><\/ul>\n<p>Qualifications<\/p>\n<ul><li>Must pass a pre-employment physical, drug (including the use of marijuana) and alcohol screening, Motor Vehicle Report (MVR), and additional background screening as required by regulation and\/or industry practice.<\/li><li>Must have a valid driver's license.<\/li><li>Must be willing to travel and work in remote locations, outside, and in all weather conditions (heat and cold)<\/li><li>Experience repairing and maintaining underground drill&nbsp;equipment (U6 and U8).<\/li><li>Experience running, maneuvering, navigating, or driving vehicles or mechanized equipment, such as forklifts, passenger and heavy equipment, and vehicles.<\/li><li>Experience analyzing information and evaluating results to choose the best solution and solve problems.<\/li><li>Experience inspecting equipment, structures, or materials to identify the cause of errors or other problems or defects.<\/li><li>Ability to understand and carry out general instructions in standard situations.<\/li><li>Ability to make decisions with a general understanding of procedures and company policies to achieve set results and deadlines.<\/li><li>Ability to multi-task and work under aggressive deadline pressure.<\/li><li>Ability to maintain a positive outlook when challenged with difficult or unknown problems.<\/li><li>Possess good time management skills.<\/li><\/ul>","%category%":"Operations","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/3dbe32260365-underground-drill-mechanic","%breezy_id%":"3dbe32260365","%breezy_friendly_id%":"3dbe32260365-underground-drill-mechanic","%breezy_created_date%":"2025-01-14T18:20:04.554Z","%breezy_updated_date%":"2025-01-15T15:47:15.049Z","%_wpgmp_location_city%":"Elko","%_wpgmp_location_state%":"NV","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Elko, NV, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"40.8436459","%_wpgmp_metabox_longitude%":"-115.7526187","%rank_math_internal_links_processed%":"1"}},"id":2089,"infowindow_disable":false},{"source":"post","title":"Front End Loader Operator &#8211; Mining","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Front End Loader Operator &#8211; Mining\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Turner Mining Group \u2013 Heavy Equipment Operator Do you love mining? Do you think differently? Are you ready to define&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/loader-operator-3\/\" name=\"Front End Loader Operator &#8211; Mining\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Turner Mining Group \u2013 Heavy Equipment Operator Do you love mining? Do you think differently? Are you ready to define&hellip;","address":"Kermit, TX, USA","location":{"lat":"31.8576265","city":"Kermit","state":"TX","country":"United States","lng":"-103.0926652","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/loader-operator-3\/","zoom":19,"extra_fields":{"post_excerpt":"Turner Mining Group \u2013 Heavy Equipment Operator Do you love mining? Do you think differently? Are you ready to define&hellip;","post_content":"<p><strong><u>Turner Mining Group \u2013 Heavy Equipment Operator<\/u><\/strong><\/p>\n<p>Do you love mining? Do you think differently? Are you ready to define the future of this industry?<\/p>\n<p>We\u2019ve been waiting for you! Turner Mining Group is committed to changing the way mining companies do business. We develop our people. We partner with our clients. We believe in win, win, win.<\/p>\n<p>We are looking for a dynamic and talented mining Heavy Equipment Operators for our fast-growing, forward thinking mining services company headquartered in Bloomington, Indiana with our Operations team headquartered in Salt Lake City, Utah.<\/p>\n<p>Turner Mining Group is seeking an energetic mining professionals who can leverage their mining knowledge to expand upon our fast-growing business, creating best practices for equipment operations to ensure profitable operations.<\/p>\n<p><strong>You<\/strong><\/p>\n<p>You want to work for a services company that is rapidly changing the way the largest materials producers do business. You are motivated by solving problems and partnering with our clients and suppliers. You want to work with great people and enjoy being a part of a strong team. You are a knowledgeable Operator who is not afraid to jump into every detail. You want to be in a place where continuous learning and growth is the norm. You are adaptable and able to juggle multiple initiatives concurrently.<\/p>\n<p><strong>Responsibilities:<\/strong><\/p>\n<ul><li>Operating heavy equipment including loaders, scrapers, blade, excavators, dozers, haul trucks, and other pieces of heavy equipment in a production environment<\/li><li>Performing all pre-shift inspections, some basic maintenance and upkeep<\/li><li>Working with teammates on crew to maximize production while always maintaining our safety rules and regulations.<\/li><\/ul>\n<p><strong>Requirements:<\/strong><\/p>\n<ul><li>Safety oriented, awareness of everyone and everything that is around you<\/li><li>Strong work ethic<\/li><li>Willingness to learn<\/li><li>Ability to be flexible and to adapt<\/li><li>Experience with heavy equipment<\/li><li>Preferred to have MSHA training<\/li><\/ul>\n<p><strong>Benefits:<\/strong><\/p>\n<p>Turner Mining Group offers a competitive salary, an excellent work culture, career advancement opportunities. Our team offers a benefits program which includes Medical, Dental, Vision, Life, and a 401k with company match.<\/p>\n<p>At Turner Mining Group, we encourage and celebrate an inclusive environment for all employees and are proud to be an equal opportunity workplace and affirmative action employer.<\/p>","post_title":"Front End Loader Operator &#8211; Mining","post_link":"https:\/\/turnerstaffing.com\/position\/loader-operator-3\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Associate","%location_country%":"United States","%location_city%":"Kermit","%location_state_id%":"TX","%location_state_name%":"Texas","%location_city_state%":"Kermit, TX","%education%":"High School or equivalent","%department%":"Operations","%description%":"<p><strong><u>Turner Mining Group \u2013 Heavy Equipment Operator<\/u><\/strong><\/p>\n<p>Do you love mining? Do you think differently? Are you ready to define the future of this industry?<\/p>\n<p>We\u2019ve been waiting for you! Turner Mining Group is committed to changing the way mining companies do business. We develop our people. We partner with our clients. We believe in win, win, win.<\/p>\n<p>We are looking for a dynamic and talented mining Heavy Equipment Operators for our fast-growing, forward thinking mining services company headquartered in Bloomington, Indiana with our Operations team headquartered in Salt Lake City, Utah.<\/p>\n<p>Turner Mining Group is seeking an energetic mining professionals who can leverage their mining knowledge to expand upon our fast-growing business, creating best practices for equipment operations to ensure profitable operations.<\/p>\n<p><strong>You<\/strong><\/p>\n<p>You want to work for a services company that is rapidly changing the way the largest materials producers do business. You are motivated by solving problems and partnering with our clients and suppliers. You want to work with great people and enjoy being a part of a strong team. You are a knowledgeable Operator who is not afraid to jump into every detail. You want to be in a place where continuous learning and growth is the norm. You are adaptable and able to juggle multiple initiatives concurrently.<\/p>\n<p><strong>Responsibilities:<\/strong><\/p>\n<ul><li>Operating heavy equipment including loaders, scrapers, blade, excavators, dozers, haul trucks, and other pieces of heavy equipment in a production environment<\/li><li>Performing all pre-shift inspections, some basic maintenance and upkeep<\/li><li>Working with teammates on crew to maximize production while always maintaining our safety rules and regulations.<\/li><\/ul>\n<p><strong>Requirements:<\/strong><\/p>\n<ul><li>Safety oriented, awareness of everyone and everything that is around you<\/li><li>Strong work ethic<\/li><li>Willingness to learn<\/li><li>Ability to be flexible and to adapt<\/li><li>Experience with heavy equipment<\/li><li>Preferred to have MSHA training<\/li><\/ul>\n<p><strong>Benefits:<\/strong><\/p>\n<p>Turner Mining Group offers a competitive salary, an excellent work culture, career advancement opportunities. Our team offers a benefits program which includes Medical, Dental, Vision, Life, and a 401k with company match.<\/p>\n<p>At Turner Mining Group, we encourage and celebrate an inclusive environment for all employees and are proud to be an equal opportunity workplace and affirmative action employer.<\/p>","%category%":"Operations","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/35c6d2912685-front-end-loader-operator-mining","%breezy_id%":"35c6d2912685","%breezy_friendly_id%":"35c6d2912685-front-end-loader-operator-mining","%breezy_created_date%":"2024-05-28T11:43:41.929Z","%breezy_updated_date%":"2025-03-17T19:56:02.681Z","%_wpgmp_location_city%":"Kermit","%_wpgmp_location_state%":"TX","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Kermit, TX, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"31.8576265","%_wpgmp_metabox_longitude%":"-103.0926652","%rank_math_internal_links_processed%":"1"}},"id":2047,"infowindow_disable":false},{"source":"post","title":"Geotechnician","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Geotechnician\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Join our dynamic team at one of Alaska&#8217;s premier gold mines as a Geotechnician! This is a unique opportunity for&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/geotechnician-2\/\" name=\"Geotechnician\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Join our dynamic team at one of Alaska&#8217;s premier gold mines as a Geotechnician! This is a unique opportunity for&hellip;","address":"Fairbanks, AK, USA","location":{"lat":"64.8400511","city":"Fairbanks","state":"AK","country":"United States","lng":"-147.7199756","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/geotechnician-2\/","zoom":19,"extra_fields":{"post_excerpt":"Join our dynamic team at one of Alaska&#8217;s premier gold mines as a Geotechnician! This is a unique opportunity for&hellip;","post_content":"<p style=\"color:#374151\">Join our dynamic team at one of Alaska's premier gold mines as a Geotechnician! This is a unique opportunity for an individual with a passion for geology and hands-on fieldwork. As a Geotechnician, you will play a crucial role in the exploration and development of a gold mine near Fairbanks. This position provides an exciting work-life balance for those ready to embrace the challenges and rewards of the mining industry.<\/p><p style=\"color:#374151\"><span style=\"color:var(--tw-prose-bold)\">Key Responsibilities:<\/span><\/p><ol><li><span style=\"color:var(--tw-prose-bold)\">Rock Core Management:<\/span> Transporting, cutting, prepping, and logging rock core samples with precision and attention to detail.<\/li><li><span style=\"color:var(--tw-prose-bold)\">Field Operations:<\/span> Conduct field surveys, collect geological data, and contribute to the overall geological assessment of the mine site.<\/li><li><span style=\"color:var(--tw-prose-bold)\">Safety Compliance:<\/span> Adhere to strict safety protocols and procedures to ensure a secure working environment for yourself and your team.<\/li><li><span style=\"color:var(--tw-prose-bold)\">Equipment Operation:<\/span> Operate various geotechnical tools and machinery with a focus on safety and efficiency.<\/li><li><span style=\"color:var(--tw-prose-bold)\">Data Recording and Analysis:<\/span> Maintain accurate records of geological data and collaborate with the geology team to analyze findings.<\/li><\/ol><p style=\"color:#374151\"><span style=\"color:var(--tw-prose-bold)\">Qualifications:<\/span><\/p><ol><li><span style=\"color:var(--tw-prose-bold)\">Experience:<\/span> Prior experience in a mining or exploration environment is preferred, but not mandatory.<\/li><li><span style=\"color:var(--tw-prose-bold)\">License:<\/span> Valid driver's license and a clean driving record are required.<\/li><li><span style=\"color:var(--tw-prose-bold)\">Physical Ability:<\/span> Ability to lift 50 lbs repeatedly throughout the shift and work in challenging outdoor conditions.<\/li><li><span style=\"color:var(--tw-prose-bold)\">Communication Skills:<\/span> Strong verbal and written communication skills for effective collaboration within the team.<\/li><li><span style=\"color:var(--tw-prose-bold)\">Adaptability:<\/span> Willingness to work in a dynamic and changing environment, adapting to the needs of the project.<\/li><li>Must be authorized to work in the US without work visa sponsorship.<\/li><li>Local candidates only, please.<\/li><\/ol><p><span style=\"color:#222222\">Applicants must be authorized to work for ANY employer in the U.S. We are unable to sponsor or take over sponsorship of an employment Visa at this time.<\/span><\/p>","post_title":"Geotechnician","post_link":"https:\/\/turnerstaffing.com\/position\/geotechnician-2\/","post_featured_image":"","post_categories":"","post_tags":"","%location_country%":"United States","%location_city%":"Fairbanks","%location_state_id%":"AK","%location_city_state%":"Fairbanks, AK","%description%":"<p style=\"color:#374151;\">Join our dynamic team at one of Alaska's premier gold mines as a Geotechnician! This is a unique opportunity for an individual with a passion for geology and hands-on fieldwork. As a Geotechnician, you will play a crucial role in the exploration and development of a gold mine near Fairbanks. This position provides an exciting work-life balance for those ready to embrace the challenges and rewards of the mining industry.<\/p><p style=\"color:#374151;\"><span style=\"color:var(--tw-prose-bold);\">Key Responsibilities:<\/span><\/p><ol><li><span style=\"color:var(--tw-prose-bold);\">Rock Core Management:<\/span> Transporting, cutting, prepping, and logging rock core samples with precision and attention to detail.<\/li><li><span style=\"color:var(--tw-prose-bold);\">Field Operations:<\/span> Conduct field surveys, collect geological data, and contribute to the overall geological assessment of the mine site.<\/li><li><span style=\"color:var(--tw-prose-bold);\">Safety Compliance:<\/span> Adhere to strict safety protocols and procedures to ensure a secure working environment for yourself and your team.<\/li><li><span style=\"color:var(--tw-prose-bold);\">Equipment Operation:<\/span> Operate various geotechnical tools and machinery with a focus on safety and efficiency.<\/li><li><span style=\"color:var(--tw-prose-bold);\">Data Recording and Analysis:<\/span> Maintain accurate records of geological data and collaborate with the geology team to analyze findings.<\/li><\/ol><p style=\"color:#374151;\"><span style=\"color:var(--tw-prose-bold);\">Qualifications:<\/span><\/p><ol><li><span style=\"color:var(--tw-prose-bold);\">Experience:<\/span> Prior experience in a mining or exploration environment is preferred, but not mandatory.<\/li><li><span style=\"color:var(--tw-prose-bold);\">License:<\/span> Valid driver's license and a clean driving record are required.<\/li><li><span style=\"color:var(--tw-prose-bold);\">Physical Ability:<\/span> Ability to lift 50 lbs repeatedly throughout the shift and work in challenging outdoor conditions.<\/li><li><span style=\"color:var(--tw-prose-bold);\">Communication Skills:<\/span> Strong verbal and written communication skills for effective collaboration within the team.<\/li><li><span style=\"color:var(--tw-prose-bold);\">Adaptability:<\/span> Willingness to work in a dynamic and changing environment, adapting to the needs of the project.<\/li><li>Must be authorized to work in the US without work visa sponsorship.<\/li><li>Local candidates only, please.<\/li><\/ol><p><span style=\"color:#222222;\">Applicants must be authorized to work for ANY employer in the U.S. We are unable to sponsor or take over sponsorship of an employment Visa at this time.<\/span><\/p>","%application_url%":"https:\/\/jobs.crelate.com\/portal\/turnerstaffinggroup\/job\/qtb54qtyq3oapt868h13m1wqsh","%crelate_id%":"qtb54qtyq3oapt868h13m1wqsh","%crelate_created_date%":"2024-12-18T14:00:05.59Z","%crelate_updated_date%":"2025-03-28T12:53:06.34Z","%_wpgmp_location_city%":"Fairbanks","%_wpgmp_location_state%":"AK","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Fairbanks, AK, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"64.8400511","%_wpgmp_metabox_longitude%":"-147.7199756","%rank_math_internal_links_processed%":"1"}},"id":2040,"infowindow_disable":false},{"source":"post","title":"Geotechnician","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Geotechnician\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Join our dynamic team at one of Alaska&#8217;s premier gold mines as a Geotechnician! This is a unique opportunity for&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/geotechnician\/\" name=\"Geotechnician\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Join our dynamic team at one of Alaska&#8217;s premier gold mines as a Geotechnician! This is a unique opportunity for&hellip;","address":"Fairbanks, AK, USA","location":{"lat":"64.8400511","city":"Fairbanks","state":"AK","country":"United States","lng":"-147.7199756","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/geotechnician\/","zoom":19,"extra_fields":{"post_excerpt":"Join our dynamic team at one of Alaska&#8217;s premier gold mines as a Geotechnician! This is a unique opportunity for&hellip;","post_content":"<p>Join our dynamic team at one of Alaska's premier gold mines as a Geotechnician! This is a unique opportunity for an individual with a passion for geology and hands-on fieldwork. As a Geotechnician, you will play a crucial role in the exploration and development of a gold mine near Fairbanks. This position provides an exciting work-life balance for those ready to embrace the challenges and rewards of the mining industry.<\/p>\n<p>Key Responsibilities:<\/p>\n<ol><li>Rock Core Management:&nbsp;Transporting, cutting, prepping, and logging rock core samples with precision and attention to detail.<\/li><li>Field Operations:&nbsp;Conduct field surveys, collect geological data, and contribute to the overall geological assessment of the mine site.<\/li><li>Safety Compliance:&nbsp;Adhere to strict safety protocols and procedures to ensure a secure working environment for yourself and your team.<\/li><li>Equipment Operation:&nbsp;Operate various geotechnical tools and machinery with a focus on safety and efficiency.<\/li><li>Data Recording and Analysis:&nbsp;Maintain accurate records of geological data and collaborate with the geology team to analyze findings.<\/li><\/ol>\n<p>Qualifications:<\/p>\n<ol><li>Experience:&nbsp;Prior experience in a mining or exploration environment is preferred, but not mandatory.<\/li><li>License:&nbsp;Valid driver's license and a clean driving record are required.<\/li><li>Physical Ability:&nbsp;Ability to lift 50 lbs repeatedly throughout the shift and work in challenging outdoor conditions.<\/li><li>Communication Skills:&nbsp;Strong verbal and written communication skills for effective collaboration within the team.<\/li><li>Adaptability:&nbsp;Willingness to work in a dynamic and changing environment, adapting to the needs of the project.<\/li><li>Must be authorized to work in the US without work visa sponsorship.<\/li><li>Local candidates only, please.<\/li><\/ol>\n<p>Applicants must be authorized to work for ANY employer in the U.S. We are unable to sponsor or take over sponsorship of an employment Visa at this time.<\/p>","post_title":"Geotechnician","post_link":"https:\/\/turnerstaffing.com\/position\/geotechnician\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"","%location_country%":"United States","%location_city%":"Fairbanks","%location_state_id%":"AK","%location_state_name%":"Alaska","%location_city_state%":"Fairbanks, AK","%education%":"","%department%":"","%description%":"<p>Join our dynamic team at one of Alaska's premier gold mines as a Geotechnician! This is a unique opportunity for an individual with a passion for geology and hands-on fieldwork. As a Geotechnician, you will play a crucial role in the exploration and development of a gold mine near Fairbanks. This position provides an exciting work-life balance for those ready to embrace the challenges and rewards of the mining industry.<\/p>\n<p>Key Responsibilities:<\/p>\n<ol><li>Rock Core Management:&nbsp;Transporting, cutting, prepping, and logging rock core samples with precision and attention to detail.<\/li><li>Field Operations:&nbsp;Conduct field surveys, collect geological data, and contribute to the overall geological assessment of the mine site.<\/li><li>Safety Compliance:&nbsp;Adhere to strict safety protocols and procedures to ensure a secure working environment for yourself and your team.<\/li><li>Equipment Operation:&nbsp;Operate various geotechnical tools and machinery with a focus on safety and efficiency.<\/li><li>Data Recording and Analysis:&nbsp;Maintain accurate records of geological data and collaborate with the geology team to analyze findings.<\/li><\/ol>\n<p>Qualifications:<\/p>\n<ol><li>Experience:&nbsp;Prior experience in a mining or exploration environment is preferred, but not mandatory.<\/li><li>License:&nbsp;Valid driver's license and a clean driving record are required.<\/li><li>Physical Ability:&nbsp;Ability to lift 50 lbs repeatedly throughout the shift and work in challenging outdoor conditions.<\/li><li>Communication Skills:&nbsp;Strong verbal and written communication skills for effective collaboration within the team.<\/li><li>Adaptability:&nbsp;Willingness to work in a dynamic and changing environment, adapting to the needs of the project.<\/li><li>Must be authorized to work in the US without work visa sponsorship.<\/li><li>Local candidates only, please.<\/li><\/ol>\n<p>Applicants must be authorized to work for ANY employer in the U.S. We are unable to sponsor or take over sponsorship of an employment Visa at this time.<\/p>","%category%":"","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/266a398b77e7-geotechnician","%breezy_id%":"266a398b77e7","%breezy_friendly_id%":"266a398b77e7-geotechnician","%breezy_created_date%":"2024-12-18T14:01:41.563Z","%breezy_updated_date%":"2024-12-18T14:02:15.476Z","%_wpgmp_location_city%":"Fairbanks","%_wpgmp_location_state%":"AK","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Fairbanks, AK, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"64.8400511","%_wpgmp_metabox_longitude%":"-147.7199756","%rank_math_internal_links_processed%":"1"}},"id":2039,"infowindow_disable":false},{"source":"post","title":"Mining Superintendent &#8211; Traveling","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Mining Superintendent &#8211; Traveling\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Turner Mining Group &#8211; Project Superintendent We are looking for a dynamic and talented mining industry leader to fill a&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/site-superintendent-traveling\/\" name=\"Mining Superintendent &#8211; Traveling\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Turner Mining Group &#8211; Project Superintendent We are looking for a dynamic and talented mining industry leader to fill a&hellip;","address":"Kermit, TX, USA","location":{"lat":"31.8576265","city":"Kermit","state":"TX","country":"United States","lng":"-103.0926652","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/site-superintendent-traveling\/","zoom":19,"extra_fields":{"post_excerpt":"Turner Mining Group &#8211; Project Superintendent We are looking for a dynamic and talented mining industry leader to fill a&hellip;","post_content":"<p><strong><u>Turner Mining Group - Project Superintendent <\/u><\/strong><br><\/p>\n\n<p>We are looking for a dynamic and talented mining industry leader to fill a Traveling Project Superintendent role at our fast-growing, forward thinking mining services company.&nbsp;<\/p>\n<p>Turner Mining Group is seeking an energetic mining professional who can leverage their mining industry experience to expand upon our fast-growing business, creating best practices for operations management and scalable business processes to ensure profitable projects. <\/p>\n<p>This person will function as a Project Superintendent, overseeing mining operations, work directly with the Senior Vice President of Mining, develop and mentor on-site management, and coordinating with home-office team. Leadership and an ability to problem solve while ensuring mining operations remain on budget and ahead of schedule. This is an opportunity to work as part of the executive leadership team in a fast-paced and flexible environment.<\/p>\n<p><strong>You<\/strong><\/p>\n<p>You want to work for a services company that is rapidly changing the way the largest mining producers do business. You are motivated by solving problems and partnering with our clients and suppliers. You want to work with great people and enjoy being a part of a strong team. You are a seasoned mining leader who is not afraid to jump into every detail. You want to be in a place where continuous learning and growth is the norm. You are adaptable and able to juggle multiple initiatives concurrently.<\/p>\n<p><strong>Position Overview<\/strong><\/p>\n<p>The Project Superintendent primary responsibility is to oversee mining operations within Turner Mining Group. This will include managing the operational and financial performance of projects, implementing processes to ensure effective personnel growth, equipment readiness, client interactions and problem solving and implementing systems and tools to increase efficiency and ensure profitability. Position reports directly to the Director of Operations.<\/p>\n<p><strong>Key Responsibilities<\/strong><\/p>\n<ul><li>Conduct field personnel development by training and monitoring: Equipment operators, maintenance technicians, grade staking, GPS utilization, foremen\u2019s, etc.<\/li><li>Ownership for project budget, profitability, and cost control<\/li><li>Identify, assist with develop, and understand the key financial and operational metrics for success<\/li><li>Oversee operations for safety and compliance<\/li><li>Developing and leading fields teams to increase performance<\/li><li>Implement business division reporting and metrics reviews<\/li><li>Coordinate site needs, crews for scheduling, planning, and resources<\/li><li>Monitor forward-looking personnel requirements and vendor developments<\/li><li>Negotiate and manage client and vendor relationships<\/li><li>Approve appropriate invoices and proposal submissions<\/li><li>Assist Biz Dev &amp; Estimation Team with Pre-Bid site visits, analysis, and work plans for project proposals<\/li><\/ul>\n<p><strong>Essential Skills &amp; Knowledge<\/strong><\/p>\n<ul><li>Detailed understanding of civil and mining operations<\/li><li>General understanding of business leadership<\/li><li>Ability to oversee operational and organizational performance for mining projects<\/li><li>Solid understanding of financial and operational reporting<\/li><li>Ability to quantify and explain variances to owners and executives succinctly and clearly<\/li><li>Proficiency in civil and mining best practices to perform project management<\/li><li>Intelligent with demonstrated results from creativity<\/li><li>Willingness to learn what is takes to run growing and successful teams<\/li><li>Strong organizational, interpersonal, and written communication skill<\/li><li>Gifted person who can prioritize and balance competing initiatives and activities<\/li><li>Knack for continuous improvement of processes, solution-based issue resolution and outcomes<\/li><li>Organized, problem solver and solution developer, who can work with workers, engineers and owner teams<\/li><li>Believe in the power of culture with strong leadership qualities<\/li><\/ul>\n<p><strong>Benefits<\/strong><\/p>\n<p>Turner Mining Group offers a competitive salary, an excellent work culture, career advancement opportunities. Our team offers a benefits program which includes Medical, Dental, Vision, Life, and a 401k with company match. We believe in a work life balance and established a Paid Time Off policy as well as paid time off for major holidays.<\/p>\n<p>At Turner Mining Group, we encourage and celebrate an inclusive environment for all employees and are proud to be an equal opportunity workplace and affirmative action employer.<\/p>","post_title":"Mining Superintendent &#8211; Traveling","post_link":"https:\/\/turnerstaffing.com\/position\/site-superintendent-traveling\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Senior","%location_country%":"United States","%location_city%":"Kermit","%location_state_id%":"TX","%location_state_name%":"Texas","%location_city_state%":"Kermit, TX","%education%":"Unspecified","%department%":"Operations","%description%":"<p><strong><u>Turner Mining Group - Project Superintendent <\/u><\/strong><br><\/p>\n\n<p>We are looking for a dynamic and talented mining industry leader to fill a Traveling Project Superintendent role at our fast-growing, forward thinking mining services company.&nbsp;<\/p>\n<p>Turner Mining Group is seeking an energetic mining professional who can leverage their mining industry experience to expand upon our fast-growing business, creating best practices for operations management and scalable business processes to ensure profitable projects. <\/p>\n<p>This person will function as a Project Superintendent, overseeing mining operations, work directly with the Senior Vice President of Mining, develop and mentor on-site management, and coordinating with home-office team. Leadership and an ability to problem solve while ensuring mining operations remain on budget and ahead of schedule. This is an opportunity to work as part of the executive leadership team in a fast-paced and flexible environment.<\/p>\n<p><strong>You<\/strong><\/p>\n<p>You want to work for a services company that is rapidly changing the way the largest mining producers do business. You are motivated by solving problems and partnering with our clients and suppliers. You want to work with great people and enjoy being a part of a strong team. You are a seasoned mining leader who is not afraid to jump into every detail. You want to be in a place where continuous learning and growth is the norm. You are adaptable and able to juggle multiple initiatives concurrently.<\/p>\n<p><strong>Position Overview<\/strong><\/p>\n<p>The Project Superintendent primary responsibility is to oversee mining operations within Turner Mining Group. This will include managing the operational and financial performance of projects, implementing processes to ensure effective personnel growth, equipment readiness, client interactions and problem solving and implementing systems and tools to increase efficiency and ensure profitability. Position reports directly to the Director of Operations.<\/p>\n<p><strong>Key Responsibilities<\/strong><\/p>\n<ul><li>Conduct field personnel development by training and monitoring: Equipment operators, maintenance technicians, grade staking, GPS utilization, foremen\u2019s, etc.<\/li><li>Ownership for project budget, profitability, and cost control<\/li><li>Identify, assist with develop, and understand the key financial and operational metrics for success<\/li><li>Oversee operations for safety and compliance<\/li><li>Developing and leading fields teams to increase performance<\/li><li>Implement business division reporting and metrics reviews<\/li><li>Coordinate site needs, crews for scheduling, planning, and resources<\/li><li>Monitor forward-looking personnel requirements and vendor developments<\/li><li>Negotiate and manage client and vendor relationships<\/li><li>Approve appropriate invoices and proposal submissions<\/li><li>Assist Biz Dev &amp; Estimation Team with Pre-Bid site visits, analysis, and work plans for project proposals<\/li><\/ul>\n<p><strong>Essential Skills &amp; Knowledge<\/strong><\/p>\n<ul><li>Detailed understanding of civil and mining operations<\/li><li>General understanding of business leadership<\/li><li>Ability to oversee operational and organizational performance for mining projects<\/li><li>Solid understanding of financial and operational reporting<\/li><li>Ability to quantify and explain variances to owners and executives succinctly and clearly<\/li><li>Proficiency in civil and mining best practices to perform project management<\/li><li>Intelligent with demonstrated results from creativity<\/li><li>Willingness to learn what is takes to run growing and successful teams<\/li><li>Strong organizational, interpersonal, and written communication skill<\/li><li>Gifted person who can prioritize and balance competing initiatives and activities<\/li><li>Knack for continuous improvement of processes, solution-based issue resolution and outcomes<\/li><li>Organized, problem solver and solution developer, who can work with workers, engineers and owner teams<\/li><li>Believe in the power of culture with strong leadership qualities<\/li><\/ul>\n<p><strong>Benefits<\/strong><\/p>\n<p>Turner Mining Group offers a competitive salary, an excellent work culture, career advancement opportunities. Our team offers a benefits program which includes Medical, Dental, Vision, Life, and a 401k with company match. We believe in a work life balance and established a Paid Time Off policy as well as paid time off for major holidays.<\/p>\n<p>At Turner Mining Group, we encourage and celebrate an inclusive environment for all employees and are proud to be an equal opportunity workplace and affirmative action employer.<\/p>","%category%":"Operations","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/4bb28f921a26-mining-superintendent-traveling","%breezy_id%":"4bb28f921a26","%breezy_friendly_id%":"4bb28f921a26-mining-superintendent-traveling","%breezy_created_date%":"2024-12-10T13:58:54.602Z","%breezy_updated_date%":"2025-03-12T14:19:13.619Z","%_wpgmp_location_city%":"Kermit","%_wpgmp_location_state%":"TX","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Kermit, TX, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"31.8576265","%_wpgmp_metabox_longitude%":"-103.0926652","%rank_math_internal_links_processed%":"1"}},"id":2023,"infowindow_disable":false},{"source":"post","title":"Dozer Operator","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Dozer Operator\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Turner Mining Group \u2013 Heavy Equipment Operator We are looking for a dynamic and talented mining Heavy Equipment Operators for&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/dozer-operator-6\/\" name=\"Dozer Operator\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Turner Mining Group \u2013 Heavy Equipment Operator We are looking for a dynamic and talented mining Heavy Equipment Operators for&hellip;","address":"Kermit, TX, USA","location":{"lat":"31.8576265","city":"Kermit","state":"TX","country":"United States","lng":"-103.0926652","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/dozer-operator-6\/","zoom":19,"extra_fields":{"post_excerpt":"Turner Mining Group \u2013 Heavy Equipment Operator We are looking for a dynamic and talented mining Heavy Equipment Operators for&hellip;","post_content":"<p><strong><u>Turner Mining Group \u2013 Heavy Equipment Operator<\/u><\/strong><br><\/p>\n\n<p>We are looking for a dynamic and talented mining Heavy Equipment Operators for our fast-growing, forward thinking mining services company headquartered in Bloomington, Indiana with our Operations team headquartered in Salt Lake City, Utah.<\/p>\n<p>Turner Mining Group is seeking an energetic mining professionals who can leverage their mining knowledge to expand upon our fast-growing business, creating best practices for equipment operations to ensure profitable operations.<\/p>\n<p><strong>You<\/strong><\/p>\n<p>You want to work for a services company that is rapidly changing the way the largest materials producers do business. You are motivated by solving problems and partnering with our clients and suppliers. You want to work with great people and enjoy being a part of a strong team. You are a knowledgeable Operator who is not afraid to jump into every detail. You want to be in a place where continuous learning and growth is the norm. You are adaptable and able to juggle multiple initiatives concurrently.<\/p>\n<p><strong>Responsibilities:<\/strong><\/p>\n<ul><li>Operating heavy equipment including loaders, scrapers, blade, excavators, dozers, haul trucks, and other pieces of heavy equipment in a production environment<\/li><li>Performing all pre-shift inspections, some basic maintenance and upkeep<\/li><li>Working with teammates on crew to maximize production while always maintaining our safety rules and regulations.<\/li><\/ul>\n<p><strong>Requirements:<\/strong><\/p>\n<ul><li>Safety oriented, awareness of everyone and everything that is around you<\/li><li>Strong work ethic<\/li><li>Willingness to learn<\/li><li>Ability to be flexible and to adapt<\/li><li>Experience with heavy equipment<\/li><li>Preferred to have MSHA training<\/li><\/ul>\n<p><strong>Benefits:<\/strong><\/p>\n<p>Turner Mining Group offers a competitive salary, an excellent work culture, career advancement opportunities. Our team offers a benefits program which includes Medical, Dental, Vision, Life, and a 401k with company match.<\/p>\n<p>At Turner Mining Group, we encourage and celebrate an inclusive environment for all employees and are proud to be an equal opportunity workplace and affirmative action employer.<\/p>","post_title":"Dozer Operator","post_link":"https:\/\/turnerstaffing.com\/position\/dozer-operator-6\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Associate","%location_country%":"United States","%location_city%":"Kermit","%location_state_id%":"TX","%location_state_name%":"Texas","%location_city_state%":"Kermit, TX","%education%":"Unspecified","%department%":"Operations","%description%":"<p><strong><u>Turner Mining Group \u2013 Heavy Equipment Operator<\/u><\/strong><br><\/p>\n\n<p>We are looking for a dynamic and talented mining Heavy Equipment Operators for our fast-growing, forward thinking mining services company headquartered in Bloomington, Indiana with our Operations team headquartered in Salt Lake City, Utah.<\/p>\n<p>Turner Mining Group is seeking an energetic mining professionals who can leverage their mining knowledge to expand upon our fast-growing business, creating best practices for equipment operations to ensure profitable operations.<\/p>\n<p><strong>You<\/strong><\/p>\n<p>You want to work for a services company that is rapidly changing the way the largest materials producers do business. You are motivated by solving problems and partnering with our clients and suppliers. You want to work with great people and enjoy being a part of a strong team. You are a knowledgeable Operator who is not afraid to jump into every detail. You want to be in a place where continuous learning and growth is the norm. You are adaptable and able to juggle multiple initiatives concurrently.<\/p>\n<p><strong>Responsibilities:<\/strong><\/p>\n<ul><li>Operating heavy equipment including loaders, scrapers, blade, excavators, dozers, haul trucks, and other pieces of heavy equipment in a production environment<\/li><li>Performing all pre-shift inspections, some basic maintenance and upkeep<\/li><li>Working with teammates on crew to maximize production while always maintaining our safety rules and regulations.<\/li><\/ul>\n<p><strong>Requirements:<\/strong><\/p>\n<ul><li>Safety oriented, awareness of everyone and everything that is around you<\/li><li>Strong work ethic<\/li><li>Willingness to learn<\/li><li>Ability to be flexible and to adapt<\/li><li>Experience with heavy equipment<\/li><li>Preferred to have MSHA training<\/li><\/ul>\n<p><strong>Benefits:<\/strong><\/p>\n<p>Turner Mining Group offers a competitive salary, an excellent work culture, career advancement opportunities. Our team offers a benefits program which includes Medical, Dental, Vision, Life, and a 401k with company match.<\/p>\n<p>At Turner Mining Group, we encourage and celebrate an inclusive environment for all employees and are proud to be an equal opportunity workplace and affirmative action employer.<\/p>","%category%":"Operations","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/5d93d412f2e0-dozer-operator","%breezy_id%":"5d93d412f2e0","%breezy_friendly_id%":"5d93d412f2e0-dozer-operator","%breezy_created_date%":"2024-04-11T13:39:10.507Z","%breezy_updated_date%":"2025-03-19T12:02:46.796Z","%_wpgmp_location_city%":"Kermit","%_wpgmp_location_state%":"TX","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Kermit, TX, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"31.8576265","%_wpgmp_metabox_longitude%":"-103.0926652","%rank_math_internal_links_processed%":"1"}},"id":2003,"infowindow_disable":false},{"source":"post","title":"Haul Truck Driver &#8211; Mining","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Haul Truck Driver &#8211; Mining\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Turner Mining Group \u2013 Haul Truck Driver Do you love mining? Do you think differently? Are you ready to define&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/haul-truck-driver-2\/\" name=\"Haul Truck Driver &#8211; Mining\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Turner Mining Group \u2013 Haul Truck Driver Do you love mining? Do you think differently? Are you ready to define&hellip;","address":"Kermit, TX, USA","location":{"lat":"31.8576265","city":"Kermit","state":"TX","country":"United States","lng":"-103.0926652","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/haul-truck-driver-2\/","zoom":19,"extra_fields":{"post_excerpt":"Turner Mining Group \u2013 Haul Truck Driver Do you love mining? Do you think differently? Are you ready to define&hellip;","post_content":"<p style=\"color:#555555\"><strong><span style=\"text-decoration:underline\">Turner Mining Group \u2013 Haul Truck Driver<\/span><\/strong><\/p>\n<p style=\"color:#000000\"><span style=\"color:#333333\">Do you love mining? Do you think differently? Are you ready to define the future of this industry?<\/span><\/p>\n<p style=\"color:#000000\"><span style=\"color:#333333\">We\u2019ve been waiting for you! Turner Mining Group is committed to changing the way mining companies do business. We develop our people. We partner with our clients. We believe in win, win, win.<\/span><\/p>\n<p style=\"color:#000000\"><span style=\"color:#333333\">We are looking for a dynamic and talented mining Haul Truck Drivers for our fast-growing, forward thinking mining services company.<\/span><\/p>\n<p style=\"color:#000000\"><span style=\"color:#333333\">Turner Mining Group is seeking an energetic mining professionals who can leverage their mining knowledge to expand upon our fast-growing business, creating best practices for equipment operations to ensure profitable operations.<\/span><\/p>\n<p style=\"color:#000000\"><span style=\"color:#555555\">If you would like to get involved and make a large contribution in mining or minerals processing, then you may enjoy a position as Haul Truck Driver. This position is great for anyone who would like to begin a career in mining, has experience in a related industry but would like to learn about mining, or has experience as a miner but would like to grow into further positions with Turner Mining Group.<\/span><\/p>\n<p style=\"color:#000000\"><strong><span style=\"color:#333333\">You<\/span><\/strong><\/p>\n<p style=\"color:#000000\"><span style=\"color:#333333\">You want to work for a services company that is rapidly changing the way the largest materials producers do business. You are motivated by solving problems and partnering with our clients and suppliers. You want to work with great people and enjoy being a part of a strong team. You are a knowledgeable Operator who is not afraid to jump into every detail. You want to be in a place where continuous learning and growth is the norm. You are adaptable and able to juggle multiple initiatives concurrently.<\/span><\/p>\n<p style=\"color:#000000\"><strong><span style=\"color:#555555\">Responsibilities:<\/span><\/strong><\/p>\n<ul><li><span style=\"color:#555555\">Operate and drive heavy haul trucks to transport tons of materials over short distances in a surface environment.<\/span><\/li><li><span style=\"color:#555555\">Perform inspections of vehicle systems, equipment and accessories such as tires, lights, turn signals and brakes<\/span><\/li><li><span style=\"color:#555555\">Ensure cargo is properly loaded according to safety requirements<\/span><\/li><li><span style=\"color:#555555\">Follow all safety policies, procedures and legislation<\/span><\/li><li><span style=\"color:#555555\">Maintain paper or electronic log book<\/span><\/li><li><span style=\"color:#555555\">Communicate with Dispatcher and other Haul Truck Drivers using communication devices such as a two-ways radio or onboard computers<\/span><\/li><li><span style=\"color:#555555\">May drive special purpose vehicles, including: end dump trucks, center dump truck units and water trucks<\/span><\/li><\/ul>\n<p style=\"color:#000000\"><strong><span style=\"color:#333333\">Requirements:<\/span><\/strong><\/p>\n<ul><li><span style=\"color:#555555\">Safety oriented, awareness of everyone and everything that is around you<\/span><\/li><li><span style=\"color:#555555\">Strong work ethic<\/span><\/li><li><span style=\"color:#555555\">Willingness to learn<\/span><\/li><li><span style=\"color:#555555\">Ability to be flexible and to adapt<\/span><\/li><li><span style=\"color:#555555\">Experience with heavy equipment<\/span><\/li><li><span style=\"color:#555555\">Preferred to have MSHA training<\/span><\/li><li><span style=\"color:#555555\">Must be 18+ to apply&nbsp;<br><\/span><\/li><\/ul>\n<p style=\"color:#000000\"><strong><span style=\"color:#333333\">Benefits:<\/span><\/strong><\/p>\n<p style=\"color:#000000\"><span style=\"color:#333333\">Turner Mining Group offers a competitive salary, an excellent work culture, career advancement opportunities. Our team offers a benefits program which includes Medical, Dental, Vision, Life, and a 401k with company match.<\/span><\/p>\n<p style=\"color:#000000\"><span style=\"color:#333333\">At Turner Mining Group, we encourage and celebrate an inclusive environment for all employees and are proud to be an equal opportunity workplace and affirmative action employer.<\/span><\/p>","post_title":"Haul Truck Driver &#8211; Mining","post_link":"https:\/\/turnerstaffing.com\/position\/haul-truck-driver-2\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"","%location_country%":"United States","%location_city%":"Kermit","%location_state_id%":"TX","%location_state_name%":"Texas","%location_city_state%":"Kermit, TX","%education%":"","%department%":"","%description%":"<p style=\"color:#555555;\"><strong><span style=\"text-decoration:underline;\">Turner Mining Group \u2013 Haul Truck Driver<\/span><\/strong><\/p>\n<p style=\"color:#000000;\"><span style=\"color:#333333;\">Do you love mining? Do you think differently? Are you ready to define the future of this industry?<\/span><\/p>\n<p style=\"color:#000000;\"><span style=\"color:#333333;\">We\u2019ve been waiting for you! Turner Mining Group is committed to changing the way mining companies do business. We develop our people. We partner with our clients. We believe in win, win, win.<\/span><\/p>\n<p style=\"color:#000000;\"><span style=\"color:#333333;\">We are looking for a dynamic and talented mining Haul Truck Drivers for our fast-growing, forward thinking mining services company.<\/span><\/p>\n<p style=\"color:#000000;\"><span style=\"color:#333333;\">Turner Mining Group is seeking an energetic mining professionals who can leverage their mining knowledge to expand upon our fast-growing business, creating best practices for equipment operations to ensure profitable operations.<\/span><\/p>\n<p style=\"color:#000000;\"><span style=\"color:#555555;\">If you would like to get involved and make a large contribution in mining or minerals processing, then you may enjoy a position as Haul Truck Driver. This position is great for anyone who would like to begin a career in mining, has experience in a related industry but would like to learn about mining, or has experience as a miner but would like to grow into further positions with Turner Mining Group.<\/span><\/p>\n<p style=\"color:#000000;\"><strong><span style=\"color:#333333;\">You<\/span><\/strong><\/p>\n<p style=\"color:#000000;\"><span style=\"color:#333333;\">You want to work for a services company that is rapidly changing the way the largest materials producers do business. You are motivated by solving problems and partnering with our clients and suppliers. You want to work with great people and enjoy being a part of a strong team. You are a knowledgeable Operator who is not afraid to jump into every detail. You want to be in a place where continuous learning and growth is the norm. You are adaptable and able to juggle multiple initiatives concurrently.<\/span><\/p>\n<p style=\"color:#000000;\"><strong><span style=\"color:#555555;\">Responsibilities:<\/span><\/strong><\/p>\n<ul><li><span style=\"color:#555555;\">Operate and drive heavy haul trucks to transport tons of materials over short distances in a surface environment.<\/span><\/li><li><span style=\"color:#555555;\">Perform inspections of vehicle systems, equipment and accessories such as tires, lights, turn signals and brakes<\/span><\/li><li><span style=\"color:#555555;\">Ensure cargo is properly loaded according to safety requirements<\/span><\/li><li><span style=\"color:#555555;\">Follow all safety policies, procedures and legislation<\/span><\/li><li><span style=\"color:#555555;\">Maintain paper or electronic log book<\/span><\/li><li><span style=\"color:#555555;\">Communicate with Dispatcher and other Haul Truck Drivers using communication devices such as a two-ways radio or onboard computers<\/span><\/li><li><span style=\"color:#555555;\">May drive special purpose vehicles, including: end dump trucks, center dump truck units and water trucks<\/span><\/li><\/ul>\n<p style=\"color:#000000;\"><strong><span style=\"color:#333333;\">Requirements:<\/span><\/strong><\/p>\n<ul><li><span style=\"color:#555555;\">Safety oriented, awareness of everyone and everything that is around you<\/span><\/li><li><span style=\"color:#555555;\">Strong work ethic<\/span><\/li><li><span style=\"color:#555555;\">Willingness to learn<\/span><\/li><li><span style=\"color:#555555;\">Ability to be flexible and to adapt<\/span><\/li><li><span style=\"color:#555555;\">Experience with heavy equipment<\/span><\/li><li><span style=\"color:#555555;\">Preferred to have MSHA training<\/span><\/li><li><span style=\"color:#555555;\">Must be 18+ to apply&nbsp;<br><\/span><\/li><\/ul>\n<p style=\"color:#000000;\"><strong><span style=\"color:#333333;\">Benefits:<\/span><\/strong><\/p>\n<p style=\"color:#000000;\"><span style=\"color:#333333;\">Turner Mining Group offers a competitive salary, an excellent work culture, career advancement opportunities. Our team offers a benefits program which includes Medical, Dental, Vision, Life, and a 401k with company match.<\/span><\/p>\n<p style=\"color:#000000;\"><span style=\"color:#333333;\">At Turner Mining Group, we encourage and celebrate an inclusive environment for all employees and are proud to be an equal opportunity workplace and affirmative action employer.<\/span><\/p>","%category%":"","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/8bfd4f4f82d7-haul-truck-driver-mining","%breezy_id%":"8bfd4f4f82d7","%breezy_friendly_id%":"8bfd4f4f82d7-haul-truck-driver-mining","%breezy_created_date%":"2022-10-06T13:27:43.124Z","%breezy_updated_date%":"2025-03-06T14:28:47.092Z","%_wpgmp_location_city%":"Kermit","%_wpgmp_location_state%":"TX","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Kermit, TX, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"31.8576265","%_wpgmp_metabox_longitude%":"-103.0926652","%rank_math_internal_links_processed%":"1"}},"id":2002,"infowindow_disable":false},{"source":"post","title":"Excavator Operator","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Excavator Operator\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Turner Mining Group \u2013 Heavy Equipment Operator Do you love mining? Do you think differently? Are you ready to define&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/excavator-operator-6\/\" name=\"Excavator Operator\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Turner Mining Group \u2013 Heavy Equipment Operator Do you love mining? Do you think differently? Are you ready to define&hellip;","address":"Kermit, TX, USA","location":{"lat":"31.8576265","city":"Kermit","state":"TX","country":"United States","lng":"-103.0926652","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/excavator-operator-6\/","zoom":19,"extra_fields":{"post_excerpt":"Turner Mining Group \u2013 Heavy Equipment Operator Do you love mining? Do you think differently? Are you ready to define&hellip;","post_content":"<p style=\"color:#000000\"><strong><span style=\"text-decoration:underline\"><span style=\"color:#555555\">Turner Mining Group \u2013 Heavy Equipment Operator<\/span><\/span><\/strong><\/p>\n<p style=\"color:#000000\"><span style=\"color:#333333\">Do you love mining? Do you think differently? Are you ready to define the future of this industry?<\/span><\/p>\n<p style=\"color:#000000\"><span style=\"color:#333333\">We\u2019ve been waiting for you! Turner Mining Group is committed to changing the way mining companies do business. We develop our people. We partner with our clients. We believe in win, win, win.<\/span><\/p>\n<p style=\"color:#000000\"><span style=\"color:#333333\">We are looking for a dynamic and talented mining Heavy Equipment Operators for our fast-growing, forward thinking mining services company headquartered in Bloomington, Indiana with our Operations team headquartered in Salt Lake City, Utah.<\/span><\/p>\n<p style=\"color:#000000\"><span style=\"color:#333333\">Turner Mining Group is seeking an energetic mining professionals who can leverage their mining knowledge to expand upon our fast-growing business, creating best practices for equipment operations to ensure profitable operations.<\/span><\/p>\n<p style=\"color:#000000\"><strong><span style=\"color:#333333\">You<\/span><\/strong><\/p>\n<p style=\"color:#000000\"><span style=\"color:#333333\">You want to work for a services company that is rapidly changing the way the largest materials producers do business. You are motivated by solving problems and partnering with our clients and suppliers. You want to work with great people and enjoy being a part of a strong team. You are a knowledgeable Operator who is not afraid to jump into every detail. You want to be in a place where continuous learning and growth is the norm. You are adaptable and able to juggle multiple initiatives concurrently.<\/span><\/p>\n<p style=\"color:#000000\"><strong><span style=\"color:#555555\">Responsibilities:<\/span><\/strong><\/p>\n<ul><li>Operating heavy equipment including blade, excavators, dozers, haul trucks, and other machines<\/li><li>Performing all pre-shift inspections, some basic maintenance and upkeep<\/li><li>Working with teammates on crew to maximize production while always maintaining our safety rules and regulations.<\/li><\/ul>\n<p style=\"color:#000000\"><strong>Requirements:<\/strong><\/p>\n<ul><li><span style=\"color:#555555\">Safety oriented, awareness of everyone and everything that is around you<\/span><\/li><li><span style=\"color:#555555\">Strong work ethic<\/span><\/li><li><span style=\"color:#555555\">Willingness to learn<\/span><\/li><li><span style=\"color:#555555\">Ability to be flexible and to adapt<\/span><\/li><li><span style=\"color:#555555\">Experience with heavy equipment<\/span><\/li><li><span style=\"color:#555555\">Preferred to have MSHA training<\/span><\/li><\/ul>\n<p><strong>Benefits:<\/strong><\/p>\n<ul><p style=\"color:#000000\"><span style=\"color:#333333\">Turner Mining Group offers a competitive salary, an excellent work culture, career advancement opportunities. Our team offers a benefits program which includes Medical, Dental, Vision, Life, and a 401k with company match.<\/span><\/p><p style=\"color:#000000\"><span style=\"color:#333333\">At Turner Mining Group, we encourage and celebrate an inclusive environment for all employees and are proud to be an equal opportunity workplace and affirmative action employer.<\/span><\/p><\/ul>\n<p><\/p>","post_title":"Excavator Operator","post_link":"https:\/\/turnerstaffing.com\/position\/excavator-operator-6\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"","%location_country%":"United States","%location_city%":"Kermit","%location_state_id%":"TX","%location_state_name%":"Texas","%location_city_state%":"Kermit, TX","%education%":"","%department%":"","%description%":"<p style=\"color:#000000;\"><strong><span style=\"text-decoration:underline;\"><span style=\"color:#555555;\">Turner Mining Group \u2013 Heavy Equipment Operator<\/span><\/span><\/strong><\/p>\n<p style=\"color:#000000;\"><span style=\"color:#333333;\">Do you love mining? Do you think differently? Are you ready to define the future of this industry?<\/span><\/p>\n<p style=\"color:#000000;\"><span style=\"color:#333333;\">We\u2019ve been waiting for you! Turner Mining Group is committed to changing the way mining companies do business. We develop our people. We partner with our clients. We believe in win, win, win.<\/span><\/p>\n<p style=\"color:#000000;\"><span style=\"color:#333333;\">We are looking for a dynamic and talented mining Heavy Equipment Operators for our fast-growing, forward thinking mining services company headquartered in Bloomington, Indiana with our Operations team headquartered in Salt Lake City, Utah.<\/span><\/p>\n<p style=\"color:#000000;\"><span style=\"color:#333333;\">Turner Mining Group is seeking an energetic mining professionals who can leverage their mining knowledge to expand upon our fast-growing business, creating best practices for equipment operations to ensure profitable operations.<\/span><\/p>\n<p style=\"color:#000000;\"><strong><span style=\"color:#333333;\">You<\/span><\/strong><\/p>\n<p style=\"color:#000000;\"><span style=\"color:#333333;\">You want to work for a services company that is rapidly changing the way the largest materials producers do business. You are motivated by solving problems and partnering with our clients and suppliers. You want to work with great people and enjoy being a part of a strong team. You are a knowledgeable Operator who is not afraid to jump into every detail. You want to be in a place where continuous learning and growth is the norm. You are adaptable and able to juggle multiple initiatives concurrently.<\/span><\/p>\n<p style=\"color:#000000;\"><strong><span style=\"color:#555555;\">Responsibilities:<\/span><\/strong><\/p>\n<ul><li>Operating heavy equipment including blade, excavators, dozers, haul trucks, and other machines<\/li><li>Performing all pre-shift inspections, some basic maintenance and upkeep<\/li><li>Working with teammates on crew to maximize production while always maintaining our safety rules and regulations.<\/li><\/ul>\n<p style=\"color:#000000;\"><strong>Requirements:<\/strong><\/p>\n<ul><li><span style=\"color:#555555;\">Safety oriented, awareness of everyone and everything that is around you<\/span><\/li><li><span style=\"color:#555555;\">Strong work ethic<\/span><\/li><li><span style=\"color:#555555;\">Willingness to learn<\/span><\/li><li><span style=\"color:#555555;\">Ability to be flexible and to adapt<\/span><\/li><li><span style=\"color:#555555;\">Experience with heavy equipment<\/span><\/li><li><span style=\"color:#555555;\">Preferred to have MSHA training<\/span><\/li><\/ul>\n<p><strong>Benefits:<\/strong><\/p>\n<ul><p style=\"color:#000000;\"><span style=\"color:#333333;\">Turner Mining Group offers a competitive salary, an excellent work culture, career advancement opportunities. Our team offers a benefits program which includes Medical, Dental, Vision, Life, and a 401k with company match.<\/span><\/p><p style=\"color:#000000;\"><span style=\"color:#333333;\">At Turner Mining Group, we encourage and celebrate an inclusive environment for all employees and are proud to be an equal opportunity workplace and affirmative action employer.<\/span><\/p><\/ul>\n<p><\/p>","%category%":"","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/46ef755ebcf0-excavator-operator","%breezy_id%":"46ef755ebcf0","%breezy_friendly_id%":"46ef755ebcf0-excavator-operator","%breezy_created_date%":"2022-10-06T13:11:38.270Z","%breezy_updated_date%":"2025-03-06T19:45:32.393Z","%_wpgmp_location_city%":"Kermit","%_wpgmp_location_state%":"TX","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Kermit, TX, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"31.8576265","%_wpgmp_metabox_longitude%":"-103.0926652","%rank_math_internal_links_processed%":"1"}},"id":2001,"infowindow_disable":false},{"source":"post","title":"Operations Superintendent &#8211; Mining","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Operations Superintendent &#8211; Mining\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Operations Superintendent Manages Project Site Operations and Foremen Reports to Project Manager Project Management \u2022 Approve timecards for each shift&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/operations-superintendent\/\" name=\"Operations Superintendent &#8211; Mining\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Operations Superintendent Manages Project Site Operations and Foremen Reports to Project Manager Project Management \u2022 Approve timecards for each shift&hellip;","address":"Kermit, TX, USA","location":{"lat":"31.8576265","city":"Kermit","state":"TX","country":"United States","lng":"-103.0926652","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/operations-superintendent\/","zoom":19,"extra_fields":{"post_excerpt":"Operations Superintendent Manages Project Site Operations and Foremen Reports to Project Manager Project Management \u2022 Approve timecards for each shift&hellip;","post_content":"<p><strong><u>Operations Superintendent<\/u><\/strong><\/p>\n<p><strong>Manages Project Site Operations and Foremen Reports to Project Manager<\/strong><\/p>\n<p><strong>Project Management<\/strong><\/p>\n<p>\u2022 Approve timecards for each shift and verify accuracy<\/p>\n<p>\u2022 Assemble field work orders (FWOs) and submit for client approval daily for the prior days work<\/p>\n<p>\u2022 Submit requisitions in accounting system for project purchases<\/p>\n<p>\u2022 Complete approvals in accounting system as needed<\/p>\n<p>\u2022 Execute survey plan created by Project Manager<\/p>\n<p>\u2022 Submit results to Project Manager<\/p>\n<p>\u2022 Assemble quantities\/ FWOs and all other billable items each invoice period and submit to Project <\/p>\n<p>manager for pay app creation<\/p>\n<p>\u2022 Maintain positive working relationship with client's onsite management<\/p>\n<p>\u2022 Work with Project Manager to stay informed on client requests, communications, and changes<\/p>\n<p>\u2022 Ensure all site activities are productive and safe<\/p>\n<p>\u2022 Accompany all site guests during visits\/ inspections<\/p>\n<p>\u2022 Ensure site conditions promote safety, efficiency, and minimize equipment damage\/ wear<\/p>\n<p>\u2022 Communicate equipment issues\/ needs to Equipment Superintendent<\/p>\n<p>\u2022 Communicate materials\/ supply needs to Project Manager<\/p>\n<p>Safety Leadership<\/p>\n<p>\u2022 Invest in site foremen and operators to foster \"An Eye For Safety\u201d<\/p>\n<p>\u2022 Mitigate onsite safety risks<\/p>\n<p>\u2022 Ensure all MSHA regulations are followed and maintain site safety conditions<\/p>\n<p>\u2022 Conduct monthly site safety meeting to discuss incidents, safety trends, behavior goals, etc<\/p>\n<p>\u2022 Ensure all workplace exams are complete and accurate<\/p>\n<p>\u2022 Task training is completed properly and stored<\/p>\n<p>\u2022 Pre-op issues are corrected, and forms are filed according to TMG process<\/p>\n<p>\u2022 All safety documents are filed and stored on site<\/p>\n<p>\u2022 Follow TMG process for incident response<\/p>\n<p>\u2022 Complete incident report in HCSS Safety<\/p>\n<p>\u2022 Complete incident analysis with foremen, complete 5 Why's and RCA document, submit to Project <\/p>\n<p>Manager<\/p>\n<p><strong>Personnel Management<\/strong><\/p>\n<p>\u2022 Submit hiring requests\/ termination requestions to HR following TMG process<\/p>\n<p>\u2022 Conduct interviews for all on-site employees.<\/p>\n<p>\u2022 Complete employee reviews using TMG form, submit for approval.<\/p>\n<p>\u2022 Evaluate foreman performance<\/p>\n<p>\u2022 Document employee issues\/ disciplinary action, send to Project Manager and HR<\/p>\n<p>\u2022 Maintain full knowledge of employee handbook<\/p>\n<p><strong>Proficiencies&nbsp;<\/strong><\/p><p>HeavyJob Sage<\/p>\n<p>Email<\/p>\n<p>Word, Excel, PowerPoint<\/p>","post_title":"Operations Superintendent &#8211; Mining","post_link":"https:\/\/turnerstaffing.com\/position\/operations-superintendent\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Mid Level","%location_country%":"United States","%location_city%":"Kermit","%location_state_id%":"TX","%location_state_name%":"Texas","%location_city_state%":"Kermit, TX","%education%":"Unspecified","%department%":"Operations","%description%":"<p><strong><u>Operations Superintendent<\/u><\/strong><\/p>\n<p><strong>Manages Project Site Operations and Foremen Reports to Project Manager<\/strong><\/p>\n<p><strong>Project Management<\/strong><\/p>\n<p>\u2022 Approve timecards for each shift and verify accuracy<\/p>\n<p>\u2022 Assemble field work orders (FWOs) and submit for client approval daily for the prior days work<\/p>\n<p>\u2022 Submit requisitions in accounting system for project purchases<\/p>\n<p>\u2022 Complete approvals in accounting system as needed<\/p>\n<p>\u2022 Execute survey plan created by Project Manager<\/p>\n<p>\u2022 Submit results to Project Manager<\/p>\n<p>\u2022 Assemble quantities\/ FWOs and all other billable items each invoice period and submit to Project <\/p>\n<p>manager for pay app creation<\/p>\n<p>\u2022 Maintain positive working relationship with client's onsite management<\/p>\n<p>\u2022 Work with Project Manager to stay informed on client requests, communications, and changes<\/p>\n<p>\u2022 Ensure all site activities are productive and safe<\/p>\n<p>\u2022 Accompany all site guests during visits\/ inspections<\/p>\n<p>\u2022 Ensure site conditions promote safety, efficiency, and minimize equipment damage\/ wear<\/p>\n<p>\u2022 Communicate equipment issues\/ needs to Equipment Superintendent<\/p>\n<p>\u2022 Communicate materials\/ supply needs to Project Manager<\/p>\n<p>Safety Leadership<\/p>\n<p>\u2022 Invest in site foremen and operators to foster \"An Eye For Safety\u201d<\/p>\n<p>\u2022 Mitigate onsite safety risks<\/p>\n<p>\u2022 Ensure all MSHA regulations are followed and maintain site safety conditions<\/p>\n<p>\u2022 Conduct monthly site safety meeting to discuss incidents, safety trends, behavior goals, etc<\/p>\n<p>\u2022 Ensure all workplace exams are complete and accurate<\/p>\n<p>\u2022 Task training is completed properly and stored<\/p>\n<p>\u2022 Pre-op issues are corrected, and forms are filed according to TMG process<\/p>\n<p>\u2022 All safety documents are filed and stored on site<\/p>\n<p>\u2022 Follow TMG process for incident response<\/p>\n<p>\u2022 Complete incident report in HCSS Safety<\/p>\n<p>\u2022 Complete incident analysis with foremen, complete 5 Why's and RCA document, submit to Project <\/p>\n<p>Manager<\/p>\n<p><strong>Personnel Management<\/strong><\/p>\n<p>\u2022 Submit hiring requests\/ termination requestions to HR following TMG process<\/p>\n<p>\u2022 Conduct interviews for all on-site employees.<\/p>\n<p>\u2022 Complete employee reviews using TMG form, submit for approval.<\/p>\n<p>\u2022 Evaluate foreman performance<\/p>\n<p>\u2022 Document employee issues\/ disciplinary action, send to Project Manager and HR<\/p>\n<p>\u2022 Maintain full knowledge of employee handbook<\/p>\n<p><strong>Proficiencies&nbsp;<\/strong><\/p><p>HeavyJob Sage<\/p>\n<p>Email<\/p>\n<p>Word, Excel, PowerPoint<\/p>","%category%":"Management","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/e4c77db4577d-operations-superintendent-mining","%breezy_id%":"e4c77db4577d","%breezy_friendly_id%":"e4c77db4577d-operations-superintendent-mining","%breezy_created_date%":"2024-11-21T14:50:45.004Z","%breezy_updated_date%":"2025-03-13T18:37:17.383Z","%_wpgmp_location_city%":"Kermit","%_wpgmp_location_state%":"TX","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Kermit, TX, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"31.8576265","%_wpgmp_metabox_longitude%":"-103.0926652","%rank_math_internal_links_processed%":"1"}},"id":1979,"infowindow_disable":false},{"source":"post","title":"Maintenance Superintendent","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Maintenance Superintendent\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Turner Mining Group &#8211; Equipment Superintendent We are looking for a dynamic and talented Equipment Superintendent at our fast-growing, forward&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/maintenance-superintendent\/\" name=\"Maintenance Superintendent\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Turner Mining Group &#8211; Equipment Superintendent We are looking for a dynamic and talented Equipment Superintendent at our fast-growing, forward&hellip;","address":"Monahans, TX, USA","location":{"lat":"31.5942991","city":"Monahans","state":"TX","country":"United States","lng":"-102.8926536","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/maintenance-superintendent\/","zoom":19,"extra_fields":{"post_excerpt":"Turner Mining Group &#8211; Equipment Superintendent We are looking for a dynamic and talented Equipment Superintendent at our fast-growing, forward&hellip;","post_content":"<p><strong><u>Turner Mining Group - Equipment Superintendent <\/u><\/strong><br><\/p>\n\n<p>We are looking for a dynamic and talented Equipment Superintendent at our fast-growing, forward thinking mining services company!  This position will report directly to the Regional Equipment Manager. <\/p>\n<p><strong>Major Responsibilities:<\/strong><\/p>\n<ul><li>Safety performance of the Maintenance Department. <\/li><li>Ensure deployment of key initiatives and communication of relevant messages to all maintenance crews at site.<\/li><li>Effectively promote, deploy, and comply with all Safety &amp; Health and Environmental policies, standards, procedures and regulations across Ledcor and Maintenance.<\/li><li>Spend significant time in the field \u2013 \u201cvisible felt leadership\u201d \u2013 interacting with the workforce, ~40 - 60% of working time.<\/li><li>Provide employees with a safe and healthy work environment by ensuring provision of safe systems of work; safe work procedures; adequate training and instruction; competent supervision. <\/li><li>Develop systems and foster the required collaboration to ensure the department meets monthly targets.<\/li><li>Review competencies, Scopes of Work and Schedules of Rates for all Contractors ensuring costs are managed and controlled while complying with Contractor Controls Policies and Procedures.<\/li><li>Help develop maintenance strategy objectives and ensure they are met.<\/li><li>Ensure effective and efficient application of maintenance resources as measured by schedule compliance, PM compliance, level of planned vs. unplanned work and the ongoing management of backlog.<\/li><li>Review hazard identification, near miss and incident reports and provide follow-up as appropriate<\/li><li>Participate in incident investigations (injury, high-potential and equipment damage) as required ensure that corrective actions are effectively implemented and tracked. <\/li><li>Ensure maintenance employees and contractors working within the Group are prequalified and have the necessary commencement paperwork, competencies and qualifications to work safely and deliver quality maintenance services (has the authority to prohibit any work from being undertaken unless all requirements are met). <\/li><li>Support the development and ongoing optimization of maintenance strategies for the critical assets. <\/li><li>Ensure that all maintenance activities are scheduled effectively, utilizing business processes and supporting systems.<\/li><li>Complete performance evaluation reviews for direct reports and manage their career development.<\/li><li>Recruit for Maintenance positions. Ensure that succession planning for key roles is in place.<\/li><li>Ensure training is provided as required.<\/li><\/ul>\n<p>  <\/p>\n<p><strong>Requirements: <\/strong><\/p>\n<p><u>Essential<\/u><\/p>\n<ul><li>Minimum 3-5 years Maintenance General Foreman level or higher experience in heavy industry<\/li><li>Minimum 2+ years management of the maintenance scheduling and work flow function.<\/li><\/ul>\n<p><u>Desirable<\/u><\/p>\n<ul><li>Experience managing or supervising an equipment department<\/li><li>5 years\u2019 experience in managing maintenance.<\/li><li>Exposure to Project Management tools and techniques.<\/li><\/ul>\n<p><strong>Benefits<\/strong><\/p>\n<p>Turner Mining Group offers a competitive salary, an excellent work culture, career advancement opportunities. Our team offers a benefits program which includes Medical, Dental, Vision, Life, and a 401k with company match.  We believe in a work life balance and established paid time off for major holidays.<\/p>\n<p>At Turner Mining Group, we encourage and celebrate an inclusive environment for all employees and are proud to be an equal opportunity workplace and affirmative action employer.<\/p>","post_title":"Maintenance Superintendent","post_link":"https:\/\/turnerstaffing.com\/position\/maintenance-superintendent\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Mid Level","%location_country%":"United States","%location_city%":"Monahans","%location_state_id%":"TX","%location_state_name%":"Texas","%location_city_state%":"Monahans, TX","%education%":"Unspecified","%department%":"Maintenance","%description%":"<p><strong><u>Turner Mining Group - Equipment Superintendent <\/u><\/strong><br><\/p>\n\n<p>We are looking for a dynamic and talented Equipment Superintendent at our fast-growing, forward thinking mining services company!  This position will report directly to the Regional Equipment Manager. <\/p>\n<p><strong>Major Responsibilities:<\/strong><\/p>\n<ul><li>Safety performance of the Maintenance Department. <\/li><li>Ensure deployment of key initiatives and communication of relevant messages to all maintenance crews at site.<\/li><li>Effectively promote, deploy, and comply with all Safety &amp; Health and Environmental policies, standards, procedures and regulations across Ledcor and Maintenance.<\/li><li>Spend significant time in the field \u2013 \u201cvisible felt leadership\u201d \u2013 interacting with the workforce, ~40 - 60% of working time.<\/li><li>Provide employees with a safe and healthy work environment by ensuring provision of safe systems of work; safe work procedures; adequate training and instruction; competent supervision. <\/li><li>Develop systems and foster the required collaboration to ensure the department meets monthly targets.<\/li><li>Review competencies, Scopes of Work and Schedules of Rates for all Contractors ensuring costs are managed and controlled while complying with Contractor Controls Policies and Procedures.<\/li><li>Help develop maintenance strategy objectives and ensure they are met.<\/li><li>Ensure effective and efficient application of maintenance resources as measured by schedule compliance, PM compliance, level of planned vs. unplanned work and the ongoing management of backlog.<\/li><li>Review hazard identification, near miss and incident reports and provide follow-up as appropriate<\/li><li>Participate in incident investigations (injury, high-potential and equipment damage) as required ensure that corrective actions are effectively implemented and tracked. <\/li><li>Ensure maintenance employees and contractors working within the Group are prequalified and have the necessary commencement paperwork, competencies and qualifications to work safely and deliver quality maintenance services (has the authority to prohibit any work from being undertaken unless all requirements are met). <\/li><li>Support the development and ongoing optimization of maintenance strategies for the critical assets. <\/li><li>Ensure that all maintenance activities are scheduled effectively, utilizing business processes and supporting systems.<\/li><li>Complete performance evaluation reviews for direct reports and manage their career development.<\/li><li>Recruit for Maintenance positions. Ensure that succession planning for key roles is in place.<\/li><li>Ensure training is provided as required.<\/li><\/ul>\n<p>  <\/p>\n<p><strong>Requirements: <\/strong><\/p>\n<p><u>Essential<\/u><\/p>\n<ul><li>Minimum 3-5 years Maintenance General Foreman level or higher experience in heavy industry<\/li><li>Minimum 2+ years management of the maintenance scheduling and work flow function.<\/li><\/ul>\n<p><u>Desirable<\/u><\/p>\n<ul><li>Experience managing or supervising an equipment department<\/li><li>5 years\u2019 experience in managing maintenance.<\/li><li>Exposure to Project Management tools and techniques.<\/li><\/ul>\n<p><strong>Benefits<\/strong><\/p>\n<p>Turner Mining Group offers a competitive salary, an excellent work culture, career advancement opportunities. Our team offers a benefits program which includes Medical, Dental, Vision, Life, and a 401k with company match.  We believe in a work life balance and established paid time off for major holidays.<\/p>\n<p>At Turner Mining Group, we encourage and celebrate an inclusive environment for all employees and are proud to be an equal opportunity workplace and affirmative action employer.<\/p>","%category%":"Management","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/5140ca2a9fc8-maintenance-superintendent","%breezy_id%":"5140ca2a9fc8","%breezy_friendly_id%":"5140ca2a9fc8-maintenance-superintendent","%breezy_created_date%":"2024-11-21T14:54:19.587Z","%breezy_updated_date%":"2025-03-12T14:17:39.125Z","%_wpgmp_location_city%":"Monahans","%_wpgmp_location_state%":"TX","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Monahans, TX, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"31.5942991","%_wpgmp_metabox_longitude%":"-102.8926536","%rank_math_internal_links_processed%":"1"}},"id":1980,"infowindow_disable":false},{"source":"post","title":"Mine Electrician","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Mine Electrician\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Job Description: In the journeyman electrician role, you will perform electrical work and inspection on wiring, fixtures, outlets, and other&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/mine-electrician\/\" name=\"Mine Electrician\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Job Description: In the journeyman electrician role, you will perform electrical work and inspection on wiring, fixtures, outlets, and other&hellip;","address":"Gabbs, NV, USA","location":{"lat":"38.8690562","city":"Gabbs","state":"NV","country":"United States","lng":"-117.9228819","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/mine-electrician\/","zoom":19,"extra_fields":{"post_excerpt":"Job Description: In the journeyman electrician role, you will perform electrical work and inspection on wiring, fixtures, outlets, and other&hellip;","post_content":"<p>Job Description:<\/p>\n<p>In the journeyman electrician role, you will perform electrical work and inspection on wiring, fixtures, outlets, and other electrical components. You will replace and repair electrical equipment and devices as required. Success in this role will be demonstrated by employing effective process controls to ensure the reliability, safety, and efficient installation and maintenance of electrical systems.<\/p>\n<p>Job Requirements:<\/p>\n<p>-Must have reasonable knowledge of electrical code and installation procedures.<\/p>\n<p>-Previous experience in 2400V; 480 \u2013 3 phase motor controls and system operation.<\/p>\n<p>-Knowledge of PLC systems and programming<\/p>\n<p>-Able to read electrical blueprints.<\/p>\n<p>-Hold a Journeymen Electrician card preferred.<\/p>\n<p>-Must have a minimum of 4 years of experience as an Industrial Electrician.<\/p>\n<p>-Troubleshoot effectively with a minimum of supervision.<\/p>\n<p>-Applicant is required to furnish their own hand tools.<\/p>\n<p>-Experience in mining is helpful.<\/p>\n<p>-Must be thoroughly familiar with all aspects of safety in the electrical field.<\/p>\n<p>-Capable of working with a minimum of supervision.<\/p>\n<p>-All work described above to be done in an efficient and workman-like manner.<\/p>\n<p>-Any knowledge of welding and fabrication is a plus but not required.<\/p>\n<p>-Applicant is responsible for the housekeeping and cleanup around their work area.<\/p>\n<p>-Additional duties are required as assigned by management.<\/p>","post_title":"Mine Electrician","post_link":"https:\/\/turnerstaffing.com\/position\/mine-electrician\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"","%location_country%":"United States","%location_city%":"Gabbs","%location_state_id%":"NV","%location_state_name%":"Nevada","%location_city_state%":"Gabbs, NV","%education%":"","%department%":"","%description%":"<p>Job Description:<\/p>\n<p>In the journeyman electrician role, you will perform electrical work and inspection on wiring, fixtures, outlets, and other electrical components. You will replace and repair electrical equipment and devices as required. Success in this role will be demonstrated by employing effective process controls to ensure the reliability, safety, and efficient installation and maintenance of electrical systems.<\/p>\n<p>Job Requirements:<\/p>\n<p>-Must have reasonable knowledge of electrical code and installation procedures.<\/p>\n<p>-Previous experience in 2400V; 480 \u2013 3 phase motor controls and system operation.<\/p>\n<p>-Knowledge of PLC systems and programming<\/p>\n<p>-Able to read electrical blueprints.<\/p>\n<p>-Hold a Journeymen Electrician card preferred.<\/p>\n<p>-Must have a minimum of 4 years of experience as an Industrial Electrician.<\/p>\n<p>-Troubleshoot effectively with a minimum of supervision.<\/p>\n<p>-Applicant is required to furnish their own hand tools.<\/p>\n<p>-Experience in mining is helpful.<\/p>\n<p>-Must be thoroughly familiar with all aspects of safety in the electrical field.<\/p>\n<p>-Capable of working with a minimum of supervision.<\/p>\n<p>-All work described above to be done in an efficient and workman-like manner.<\/p>\n<p>-Any knowledge of welding and fabrication is a plus but not required.<\/p>\n<p>-Applicant is responsible for the housekeeping and cleanup around their work area.<\/p>\n<p>-Additional duties are required as assigned by management.<\/p>","%category%":"","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/9c0b376c6bbc-mine-electrician","%breezy_id%":"9c0b376c6bbc","%breezy_friendly_id%":"9c0b376c6bbc-mine-electrician","%breezy_created_date%":"2024-11-14T16:24:57.526Z","%breezy_updated_date%":"2025-03-12T14:51:58.604Z","%_wpgmp_location_city%":"Gabbs","%_wpgmp_location_state%":"NV","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Gabbs, NV, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"38.8690562","%_wpgmp_metabox_longitude%":"-117.9228819","%rank_math_internal_links_processed%":"1"}},"id":1953,"infowindow_disable":false},{"source":"post","title":"Maintenance Mechanic &#8211; Hydraulics","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Maintenance Mechanic &#8211; Hydraulics\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Position Overview We are currently hiring experienced, full-time, hourly shop and field mechanics. &nbsp;These positions diagnose, adjust, repair, fabricate, and&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/maintenance-mechanic-hydraulics\/\" name=\"Maintenance Mechanic &#8211; Hydraulics\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Position Overview We are currently hiring experienced, full-time, hourly shop and field mechanics. &nbsp;These positions diagnose, adjust, repair, fabricate, and&hellip;","address":"Phoenix, AZ, USA","location":{"lat":"33.4482266","city":"Phoenix","state":"AZ","country":"United States","lng":"-112.0776781","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/maintenance-mechanic-hydraulics\/","zoom":19,"extra_fields":{"post_excerpt":"Position Overview We are currently hiring experienced, full-time, hourly shop and field mechanics. &nbsp;These positions diagnose, adjust, repair, fabricate, and&hellip;","post_content":"<h1>Position Overview<\/h1>\n<p>We are currently hiring experienced, full-time, hourly shop and field mechanics. &nbsp;These positions diagnose, adjust, repair, fabricate, and overhaul mobile mechanical, hydraulic, and pneumatic parts, and equipment\/vehicles. Excellent welding and fabricating experience preferred.<\/p>\n<p><\/p>\n<ul><li>For field mechanics, travel is required.<\/li><li>Mechanics&nbsp;can work a 10 days on\/4 days off, or 9 days on\/5 days off schedule.&nbsp;<\/li><\/ul>\n<p><\/p>\n<h1>Essential Functions<\/h1>\n<ul><li>Demonstrate a strong commitment to safe work practices and procedures.<\/li><li>Repair and replace damaged or worn parts.<\/li><li>Operate and inspect machines or heavy equipment to diagnose defects.<\/li><li>Diagnose faults or malfunctions to determine required repairs, using engine diagnostic equipment such as computerized test equipment and calibration devices.<\/li><li>Dismantle and reassemble heavy equipment using hoists and hand tools.<\/li><li>Clean, lubricate, and perform other routine maintenance work on equipment and vehicles.<\/li><li>Examine parts for damage or excessive wear using micrometers and gauges.<\/li><li>Schedule maintenance for industrial machines and equipment and keep equipment service records.<\/li><li>Read and understand operating manuals, blueprints, and technical drawings.<\/li><li>Weld or solder broken parts and structural members using electric or gas welders and soldering tools.<\/li><li>Fabricate needed parts or items as required.<\/li><li>Exhibit a strong work ethic with the drive and desire to learn and perform tasks efficiently.&nbsp;<\/li><li>Maintain effective and collaborative workplace relationships, treating others with dignity and respect.<\/li><\/ul>\n<p><\/p>\n<h1>Qualifications<\/h1>\n<ul><li>Must pass a pre-employment physical, drug (including the use of marijuana) and alcohol screening, Motor Vehicle Report (MVR), and additional background screening as required by regulation and\/or industry practice.&nbsp;<\/li><li>Must have a valid driver's license.&nbsp;<\/li><li>Must be willing to travel and work in remote locations, outside, and in all weather conditions (heat and cold)<\/li><li>Experience repairing and maintaining mechanical equipment.<\/li><li>Experience running, maneuvering, navigating, or driving vehicles or mechanized equipment, such as forklifts, passenger and heavy equipment, and vehicles.<\/li><li>Experience analyzing information and evaluating results to choose the best solution and solve problems.<\/li><li>Experience inspecting equipment, structures, or materials to identify the cause of errors or other problems or defects.<\/li><li>Ability to understand and carry out general instructions in standard situations.<\/li><li>Ability to make decisions with a general understanding of procedures and company policies to achieve set results and deadlines.<\/li><li>Ability to multi-task and work under aggressive deadline pressure.<\/li><li>Ability to maintain a positive outlook when challenged with difficult or unknown problems.<\/li><li>Possess good time management skills.<\/li><\/ul>","post_title":"Maintenance Mechanic &#8211; Hydraulics","post_link":"https:\/\/turnerstaffing.com\/position\/maintenance-mechanic-hydraulics\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"","%location_country%":"United States","%location_city%":"Phoenix","%location_state_id%":"AZ","%location_state_name%":"Arizona","%location_city_state%":"Phoenix, AZ","%education%":"","%department%":"","%description%":"<h1>Position Overview<\/h1>\n<p>We are currently hiring experienced, full-time, hourly shop and field mechanics. &nbsp;These positions diagnose, adjust, repair, fabricate, and overhaul mobile mechanical, hydraulic, and pneumatic parts, and equipment\/vehicles. Excellent welding and fabricating experience preferred.<\/p>\n<p><\/p>\n<ul><li>For field mechanics, travel is required.<\/li><li>Mechanics&nbsp;can work a 10 days on\/4 days off, or 9 days on\/5 days off schedule.&nbsp;<\/li><\/ul>\n<p><\/p>\n<h1>Essential Functions<\/h1>\n<ul><li>Demonstrate a strong commitment to safe work practices and procedures.<\/li><li>Repair and replace damaged or worn parts.<\/li><li>Operate and inspect machines or heavy equipment to diagnose defects.<\/li><li>Diagnose faults or malfunctions to determine required repairs, using engine diagnostic equipment such as computerized test equipment and calibration devices.<\/li><li>Dismantle and reassemble heavy equipment using hoists and hand tools.<\/li><li>Clean, lubricate, and perform other routine maintenance work on equipment and vehicles.<\/li><li>Examine parts for damage or excessive wear using micrometers and gauges.<\/li><li>Schedule maintenance for industrial machines and equipment and keep equipment service records.<\/li><li>Read and understand operating manuals, blueprints, and technical drawings.<\/li><li>Weld or solder broken parts and structural members using electric or gas welders and soldering tools.<\/li><li>Fabricate needed parts or items as required.<\/li><li>Exhibit a strong work ethic with the drive and desire to learn and perform tasks efficiently.&nbsp;<\/li><li>Maintain effective and collaborative workplace relationships, treating others with dignity and respect.<\/li><\/ul>\n<p><\/p>\n<h1>Qualifications<\/h1>\n<ul><li>Must pass a pre-employment physical, drug (including the use of marijuana) and alcohol screening, Motor Vehicle Report (MVR), and additional background screening as required by regulation and\/or industry practice.&nbsp;<\/li><li>Must have a valid driver's license.&nbsp;<\/li><li>Must be willing to travel and work in remote locations, outside, and in all weather conditions (heat and cold)<\/li><li>Experience repairing and maintaining mechanical equipment.<\/li><li>Experience running, maneuvering, navigating, or driving vehicles or mechanized equipment, such as forklifts, passenger and heavy equipment, and vehicles.<\/li><li>Experience analyzing information and evaluating results to choose the best solution and solve problems.<\/li><li>Experience inspecting equipment, structures, or materials to identify the cause of errors or other problems or defects.<\/li><li>Ability to understand and carry out general instructions in standard situations.<\/li><li>Ability to make decisions with a general understanding of procedures and company policies to achieve set results and deadlines.<\/li><li>Ability to multi-task and work under aggressive deadline pressure.<\/li><li>Ability to maintain a positive outlook when challenged with difficult or unknown problems.<\/li><li>Possess good time management skills.<\/li><\/ul>","%category%":"","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/6eefa39a14e4-maintenance-mechanic-hydraulics","%breezy_id%":"6eefa39a14e4","%breezy_friendly_id%":"6eefa39a14e4-maintenance-mechanic-hydraulics","%breezy_created_date%":"2024-11-01T17:33:37.970Z","%breezy_updated_date%":"2025-02-11T15:55:25.887Z","%_wpgmp_location_city%":"Phoenix","%_wpgmp_location_state%":"AZ","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Phoenix, AZ, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"33.4482266","%_wpgmp_metabox_longitude%":"-112.0776781","%rank_math_internal_links_processed%":"1"}},"id":1919,"infowindow_disable":false},{"source":"post","title":"Maintenance Mechanic &#8211; Hydraulics","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Maintenance Mechanic &#8211; Hydraulics\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Position Overview We are currently hiring experienced, full-time, hourly shop and field mechanics. &nbsp;These positions diagnose, adjust, repair, fabricate, and&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/maintenance-mechanic-hydraulics-2\/\" name=\"Maintenance Mechanic &#8211; Hydraulics\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Position Overview We are currently hiring experienced, full-time, hourly shop and field mechanics. &nbsp;These positions diagnose, adjust, repair, fabricate, and&hellip;","address":"Elko, NV, USA","location":{"lat":"40.8436459","city":"Elko","state":"NV","country":"United States","lng":"-115.7526187","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/maintenance-mechanic-hydraulics-2\/","zoom":19,"extra_fields":{"post_excerpt":"Position Overview We are currently hiring experienced, full-time, hourly shop and field mechanics. &nbsp;These positions diagnose, adjust, repair, fabricate, and&hellip;","post_content":"<h1>Position Overview<\/h1>\n<p>We are currently hiring experienced, full-time, hourly shop and field mechanics. &nbsp;These positions diagnose, adjust, repair, fabricate, and overhaul mobile mechanical, hydraulic, and pneumatic parts, and equipment\/vehicles. Excellent welding and fabricating experience preferred.<\/p>\n<p><\/p>\n<ul><li>For field mechanics, travel is required.<\/li><li>Mechanics&nbsp;can work a 10 days on\/4 days off, or 9 days on\/5 days off schedule.&nbsp;<\/li><\/ul>\n<p><\/p>\n<h1>Essential Functions<\/h1>\n<ul><li>Demonstrate a strong commitment to safe work practices and procedures.<\/li><li>Repair and replace damaged or worn parts.<\/li><li>Operate and inspect machines or heavy equipment to diagnose defects.<\/li><li>Diagnose faults or malfunctions to determine required repairs, using engine diagnostic equipment such as computerized test equipment and calibration devices.<\/li><li>Dismantle and reassemble heavy equipment using hoists and hand tools.<\/li><li>Clean, lubricate, and perform other routine maintenance work on equipment and vehicles.<\/li><li>Examine parts for damage or excessive wear using micrometers and gauges.<\/li><li>Schedule maintenance for industrial machines and equipment and keep equipment service records.<\/li><li>Read and understand operating manuals, blueprints, and technical drawings.<\/li><li>Weld or solder broken parts and structural members using electric or gas welders and soldering tools.<\/li><li>Fabricate needed parts or items as required.<\/li><li>Exhibit a strong work ethic with the drive and desire to learn and perform tasks efficiently.&nbsp;<\/li><li>Maintain effective and collaborative workplace relationships, treating others with dignity and respect.<\/li><\/ul>\n<p><\/p>\n<h1>Qualifications<\/h1>\n<ul><li>Must pass a pre-employment physical, drug (including the use of marijuana) and alcohol screening, Motor Vehicle Report (MVR), and additional background screening as required by regulation and\/or industry practice.&nbsp;<\/li><li>Must have a valid driver's license.&nbsp;<\/li><li>Must be willing to travel and work in remote locations, outside, and in all weather conditions (heat and cold)<\/li><li>Experience repairing and maintaining mechanical equipment.<\/li><li>Experience running, maneuvering, navigating, or driving vehicles or mechanized equipment, such as forklifts, passenger and heavy equipment, and vehicles.<\/li><li>Experience analyzing information and evaluating results to choose the best solution and solve problems.<\/li><li>Experience inspecting equipment, structures, or materials to identify the cause of errors or other problems or defects.<\/li><li>Ability to understand and carry out general instructions in standard situations.<\/li><li>Ability to make decisions with a general understanding of procedures and company policies to achieve set results and deadlines.<\/li><li>Ability to multi-task and work under aggressive deadline pressure.<\/li><li>Ability to maintain a positive outlook when challenged with difficult or unknown problems.<\/li><li>Possess good time management skills.<\/li><\/ul>","post_title":"Maintenance Mechanic &#8211; Hydraulics","post_link":"https:\/\/turnerstaffing.com\/position\/maintenance-mechanic-hydraulics-2\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"","%location_country%":"United States","%location_city%":"Elko","%location_state_id%":"NV","%location_state_name%":"Nevada","%location_city_state%":"Elko, NV","%education%":"","%department%":"","%description%":"<h1>Position Overview<\/h1>\n<p>We are currently hiring experienced, full-time, hourly shop and field mechanics. &nbsp;These positions diagnose, adjust, repair, fabricate, and overhaul mobile mechanical, hydraulic, and pneumatic parts, and equipment\/vehicles. Excellent welding and fabricating experience preferred.<\/p>\n<p><\/p>\n<ul><li>For field mechanics, travel is required.<\/li><li>Mechanics&nbsp;can work a 10 days on\/4 days off, or 9 days on\/5 days off schedule.&nbsp;<\/li><\/ul>\n<p><\/p>\n<h1>Essential Functions<\/h1>\n<ul><li>Demonstrate a strong commitment to safe work practices and procedures.<\/li><li>Repair and replace damaged or worn parts.<\/li><li>Operate and inspect machines or heavy equipment to diagnose defects.<\/li><li>Diagnose faults or malfunctions to determine required repairs, using engine diagnostic equipment such as computerized test equipment and calibration devices.<\/li><li>Dismantle and reassemble heavy equipment using hoists and hand tools.<\/li><li>Clean, lubricate, and perform other routine maintenance work on equipment and vehicles.<\/li><li>Examine parts for damage or excessive wear using micrometers and gauges.<\/li><li>Schedule maintenance for industrial machines and equipment and keep equipment service records.<\/li><li>Read and understand operating manuals, blueprints, and technical drawings.<\/li><li>Weld or solder broken parts and structural members using electric or gas welders and soldering tools.<\/li><li>Fabricate needed parts or items as required.<\/li><li>Exhibit a strong work ethic with the drive and desire to learn and perform tasks efficiently.&nbsp;<\/li><li>Maintain effective and collaborative workplace relationships, treating others with dignity and respect.<\/li><\/ul>\n<p><\/p>\n<h1>Qualifications<\/h1>\n<ul><li>Must pass a pre-employment physical, drug (including the use of marijuana) and alcohol screening, Motor Vehicle Report (MVR), and additional background screening as required by regulation and\/or industry practice.&nbsp;<\/li><li>Must have a valid driver's license.&nbsp;<\/li><li>Must be willing to travel and work in remote locations, outside, and in all weather conditions (heat and cold)<\/li><li>Experience repairing and maintaining mechanical equipment.<\/li><li>Experience running, maneuvering, navigating, or driving vehicles or mechanized equipment, such as forklifts, passenger and heavy equipment, and vehicles.<\/li><li>Experience analyzing information and evaluating results to choose the best solution and solve problems.<\/li><li>Experience inspecting equipment, structures, or materials to identify the cause of errors or other problems or defects.<\/li><li>Ability to understand and carry out general instructions in standard situations.<\/li><li>Ability to make decisions with a general understanding of procedures and company policies to achieve set results and deadlines.<\/li><li>Ability to multi-task and work under aggressive deadline pressure.<\/li><li>Ability to maintain a positive outlook when challenged with difficult or unknown problems.<\/li><li>Possess good time management skills.<\/li><\/ul>","%category%":"","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/763cd94c1a7b-maintenance-mechanic-hydraulics","%breezy_id%":"763cd94c1a7b","%breezy_friendly_id%":"763cd94c1a7b-maintenance-mechanic-hydraulics","%breezy_created_date%":"2024-11-01T17:38:12.191Z","%breezy_updated_date%":"2025-02-11T15:55:26.580Z","%_wpgmp_location_city%":"Elko","%_wpgmp_location_state%":"NV","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Elko, NV, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"40.8436459","%_wpgmp_metabox_longitude%":"-115.7526187","%rank_math_internal_links_processed%":"1"}},"id":1920,"infowindow_disable":false},{"source":"post","title":"Industrial Maintenance Mechanic","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Industrial Maintenance Mechanic\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Job Description: Repairs and maintains plant equipment as assigned, including electric and gas welding, hydraulics, rigging, pipe fitting, pumps, air&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/industrial-maintenance-mechanic\/\" name=\"Industrial Maintenance Mechanic\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Job Description: Repairs and maintains plant equipment as assigned, including electric and gas welding, hydraulics, rigging, pipe fitting, pumps, air&hellip;","address":"Gabbs, NV, USA","location":{"lat":"38.8690562","city":"Gabbs","state":"NV","country":"United States","lng":"-117.9228819","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/industrial-maintenance-mechanic\/","zoom":19,"extra_fields":{"post_excerpt":"Job Description: Repairs and maintains plant equipment as assigned, including electric and gas welding, hydraulics, rigging, pipe fitting, pumps, air&hellip;","post_content":"<h3><strong>Job Description:<\/strong><br><\/h3>\n<p>Repairs and maintains plant equipment as assigned, including electric and gas welding, hydraulics, rigging, pipe fitting, pumps, air compressors, vacuum pumps, bearings and seals, power transmissions, gear boxes, equipment settings and alignment.&nbsp;<\/p><p><\/p>\n\n<p><strong>Job Requirements:<\/strong><\/p>\n<p>Must have a minimum set of hand tools as specified by the Company.&nbsp; Previous experience must include a minimum of fours years in an apprentice program, preferably a millwright program.&nbsp; If the apprentice program is not a millwright program, then the job experience must have a heavy emphasis on millwright type work.<\/p>\n<p>Must be able to read and understand blueprints and equipment instructions.<\/p>\n<p>Must be able to weld with enough proficiency to pass a Company welding test in both electrical arc and oxygen\/acetylene welding and understand the safe handling of welding equipment.&nbsp; Must be able to determine what type of rod to use on different types of steel and cast iron.<\/p>\n<p>Must be thoroughly familiar with all aspects of safety in the maintenance field.&nbsp; Must be capable of working with a minimum of supervision.<\/p>\n<p>All work described above to be done in an efficient and workman-like manner.&nbsp;<\/p>\n<p>This position is subject to duties as assigned.<\/p>\n<p><\/p>","post_title":"Industrial Maintenance Mechanic","post_link":"https:\/\/turnerstaffing.com\/position\/industrial-maintenance-mechanic\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"","%location_country%":"United States","%location_city%":"Gabbs","%location_state_id%":"NV","%location_state_name%":"Nevada","%location_city_state%":"Gabbs, NV","%education%":"","%department%":"","%description%":"<h3><strong>Job Description:<\/strong><br><\/h3>\n<p>Repairs and maintains plant equipment as assigned, including electric and gas welding, hydraulics, rigging, pipe fitting, pumps, air compressors, vacuum pumps, bearings and seals, power transmissions, gear boxes, equipment settings and alignment.&nbsp;<\/p><p><\/p>\n\n<p><strong>Job Requirements:<\/strong><\/p>\n<p>Must have a minimum set of hand tools as specified by the Company.&nbsp; Previous experience must include a minimum of fours years in an apprentice program, preferably a millwright program.&nbsp; If the apprentice program is not a millwright program, then the job experience must have a heavy emphasis on millwright type work.<\/p>\n<p>Must be able to read and understand blueprints and equipment instructions.<\/p>\n<p>Must be able to weld with enough proficiency to pass a Company welding test in both electrical arc and oxygen\/acetylene welding and understand the safe handling of welding equipment.&nbsp; Must be able to determine what type of rod to use on different types of steel and cast iron.<\/p>\n<p>Must be thoroughly familiar with all aspects of safety in the maintenance field.&nbsp; Must be capable of working with a minimum of supervision.<\/p>\n<p>All work described above to be done in an efficient and workman-like manner.&nbsp;<\/p>\n<p>This position is subject to duties as assigned.<\/p>\n<p><\/p>","%category%":"","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/b3a49aacf69b-industrial-maintenance-mechanic","%breezy_id%":"b3a49aacf69b","%breezy_friendly_id%":"b3a49aacf69b-industrial-maintenance-mechanic","%breezy_created_date%":"2024-10-01T20:08:27.898Z","%breezy_updated_date%":"2025-01-15T14:17:12.812Z","%_wpgmp_location_city%":"Gabbs","%_wpgmp_location_state%":"NV","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Gabbs, NV, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"38.8690562","%_wpgmp_metabox_longitude%":"-117.9228819","%rank_math_internal_links_processed%":"1"}},"id":1794,"infowindow_disable":false},{"source":"post","title":"Mobile Drill Mine Mechanic","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Mobile Drill Mine Mechanic\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Mechanic I-IV Do you want to work with the best people and equipment in the industry? Are you tired of&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/mobile-drill-mine-mechanic\/\" name=\"Mobile Drill Mine Mechanic\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Mechanic I-IV Do you want to work with the best people and equipment in the industry? Are you tired of&hellip;","address":"Elko, NV, USA","location":{"lat":"40.8436459","city":"Elko","state":"NV","country":"United States","lng":"-115.7526187","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/mobile-drill-mine-mechanic\/","zoom":19,"extra_fields":{"post_excerpt":"Mechanic I-IV Do you want to work with the best people and equipment in the industry? Are you tired of&hellip;","post_content":"<p><strong>Mechanic I-IV<\/strong><\/p>\n<p>Do you want to work with the best people and equipment in the industry? Are you tired of not having the parts and support needed to do your job? We offer clean, modern workspaces, fully stocked parts rooms, advanced repair and fabrication equipment, and knowledgeable, supportive leadership that will help you progress in your career.<\/p>\n<p>Our greatest asset is our team of hardworking professionals \u2013 especially our reliable and experienced maintenance crews. If you value integrity, an honest day\u2019s work, and professionalism, you will feel right at home.<\/p>\n<p>In addition to respect and appreciation for a job well done, we offer industry-leading equipment, monthly tooling allowance, competitive compensation, and travel per diem paired with a comprehensive Employee Benefit Program, including things like company-paid insurance premiums (where we pay 100% of the employee-only insurance premiums), 401(k) match, and paid time off.<\/p>\n<p>Position Overview<\/p>\n<p>We are currently hiring experienced, full-time, hourly shop and field mechanics. These positions diagnose, adjust, repair, fabricate, and overhaul mobile mechanical, hydraulic, and pneumatic parts, and equipment\/vehicles. Excellent welding and fabricating experience preferred.<\/p>\n<ul><li>For field mechanics, travel is required.<\/li><li>Mechanics can work a 10 days on\/4 days off, or 9 days on\/5 days off schedule.<\/li><\/ul>\n<p>Essential Functions<\/p>\n<ul><li>Demonstrate a strong commitment to safe work practices and procedures.<\/li><li>Repair and replace damaged or worn parts.<\/li><li>Operate and inspect machines or heavy equipment to diagnose defects.<\/li><li>Diagnose faults or malfunctions to determine required repairs, using engine diagnostic equipment such as computerized test equipment and calibration devices.<\/li><li>Dismantle and reassemble heavy equipment using hoists and hand tools.<\/li><li>Clean, lubricate, and perform other routine maintenance work on equipment and vehicles.<\/li><li>Examine parts for damage or excessive wear using micrometers and gauges.<\/li><li>Schedule maintenance for industrial machines and equipment and keep equipment service records.<\/li><li>Read and understand operating manuals, blueprints, and technical drawings.<\/li><li>Weld or solder broken parts and structural members using electric or gas welders and soldering tools.<\/li><li>Fabricate needed parts or items as required.<\/li><li>Exhibit a strong work ethic with the drive and desire to learn and perform tasks efficiently.<\/li><li>Maintain effective and collaborative workplace relationships, treating others with dignity and respect.<\/li><\/ul>\n<p>Qualifications<\/p>\n<ul><li>Must pass a pre-employment physical, drug (including the use of marijuana) and alcohol screening, Motor Vehicle Report (MVR), and additional background screening as required by regulation and\/or industry practice.<\/li><li>Must have a valid driver's license.<\/li><li>Must be willing to travel and work in remote locations, outside, and in all weather conditions (heat and cold)<\/li><li>Experience repairing and maintaining mechanical equipment.<\/li><li>Experience running, maneuvering, navigating, or driving vehicles or mechanized equipment, such as forklifts, passenger and heavy equipment, and vehicles.<\/li><li>Experience analyzing information and evaluating results to choose the best solution and solve problems.<\/li><li>Experience inspecting equipment, structures, or materials to identify the cause of errors or other problems or defects.<\/li><li>Ability to understand and carry out general instructions in standard situations.<\/li><li>Ability to make decisions with a general understanding of procedures and company policies to achieve set results and deadlines.<\/li><li>Ability to multi-task and work under aggressive deadline pressure.<\/li><li>Ability to maintain a positive outlook when challenged with difficult or unknown problems.<\/li><li>Possess good time management skills.<\/li><\/ul>\n<p>Typical Pay Schedule (Based upon experience)<\/p>\n<p>Mechanic I - $25\/hr.<\/p>\n<ul><li>One (1) to two (2) years\u2019 experience as a hydraulic and electrical mechanic.<\/li><li>New graduates will be considered if trained on heavy equipment with hydraulics.<\/li><\/ul>\n<p>Mechanic II - $30-$40\/hr.<\/p>\n<ul><li>Three (3) to five (5) years\u2019 experience as a hydraulic and electrical mechanic.<\/li><\/ul>\n<p>Mechanic III - $40-$55\/hr. (Pay determination based on shop position or field position)<\/p>\n<ul><li>Six (6) years\u2019 experience as a hydraulic and electrical mechanic.<\/li><li>Experienced drilling support equipment, such as mud systems, generators, and compressors preferred.<\/li><li>Ability to work independently in the field without the daily support from the Maintenance Supervisor.<\/li><\/ul>\n<p>Mechanic IV - $40-65\/hr. (Pay determination based on shop position or field position)<\/p>\n<ul><li>Six (6) plus years\u2019 experience as a hydraulic and electrical mechanic or strong knowledge with the ability to complete all aspects of the field mechanic position without support from the Maintenance Supervisor.<\/li><li>Experienced drilling support equipment, such as mud systems, generators, and compressors preferred.<\/li><\/ul>","post_title":"Mobile Drill Mine Mechanic","post_link":"https:\/\/turnerstaffing.com\/position\/mobile-drill-mine-mechanic\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"","%location_country%":"United States","%location_city%":"Elko","%location_state_id%":"NV","%location_state_name%":"Nevada","%location_city_state%":"Elko, NV","%education%":"","%department%":"","%description%":"<p><strong>Mechanic I-IV<\/strong><\/p>\n<p>Do you want to work with the best people and equipment in the industry? Are you tired of not having the parts and support needed to do your job? We offer clean, modern workspaces, fully stocked parts rooms, advanced repair and fabrication equipment, and knowledgeable, supportive leadership that will help you progress in your career.<\/p>\n<p>Our greatest asset is our team of hardworking professionals \u2013 especially our reliable and experienced maintenance crews. If you value integrity, an honest day\u2019s work, and professionalism, you will feel right at home.<\/p>\n<p>In addition to respect and appreciation for a job well done, we offer industry-leading equipment, monthly tooling allowance, competitive compensation, and travel per diem paired with a comprehensive Employee Benefit Program, including things like company-paid insurance premiums (where we pay 100% of the employee-only insurance premiums), 401(k) match, and paid time off.<\/p>\n<p>Position Overview<\/p>\n<p>We are currently hiring experienced, full-time, hourly shop and field mechanics. These positions diagnose, adjust, repair, fabricate, and overhaul mobile mechanical, hydraulic, and pneumatic parts, and equipment\/vehicles. Excellent welding and fabricating experience preferred.<\/p>\n<ul><li>For field mechanics, travel is required.<\/li><li>Mechanics can work a 10 days on\/4 days off, or 9 days on\/5 days off schedule.<\/li><\/ul>\n<p>Essential Functions<\/p>\n<ul><li>Demonstrate a strong commitment to safe work practices and procedures.<\/li><li>Repair and replace damaged or worn parts.<\/li><li>Operate and inspect machines or heavy equipment to diagnose defects.<\/li><li>Diagnose faults or malfunctions to determine required repairs, using engine diagnostic equipment such as computerized test equipment and calibration devices.<\/li><li>Dismantle and reassemble heavy equipment using hoists and hand tools.<\/li><li>Clean, lubricate, and perform other routine maintenance work on equipment and vehicles.<\/li><li>Examine parts for damage or excessive wear using micrometers and gauges.<\/li><li>Schedule maintenance for industrial machines and equipment and keep equipment service records.<\/li><li>Read and understand operating manuals, blueprints, and technical drawings.<\/li><li>Weld or solder broken parts and structural members using electric or gas welders and soldering tools.<\/li><li>Fabricate needed parts or items as required.<\/li><li>Exhibit a strong work ethic with the drive and desire to learn and perform tasks efficiently.<\/li><li>Maintain effective and collaborative workplace relationships, treating others with dignity and respect.<\/li><\/ul>\n<p>Qualifications<\/p>\n<ul><li>Must pass a pre-employment physical, drug (including the use of marijuana) and alcohol screening, Motor Vehicle Report (MVR), and additional background screening as required by regulation and\/or industry practice.<\/li><li>Must have a valid driver's license.<\/li><li>Must be willing to travel and work in remote locations, outside, and in all weather conditions (heat and cold)<\/li><li>Experience repairing and maintaining mechanical equipment.<\/li><li>Experience running, maneuvering, navigating, or driving vehicles or mechanized equipment, such as forklifts, passenger and heavy equipment, and vehicles.<\/li><li>Experience analyzing information and evaluating results to choose the best solution and solve problems.<\/li><li>Experience inspecting equipment, structures, or materials to identify the cause of errors or other problems or defects.<\/li><li>Ability to understand and carry out general instructions in standard situations.<\/li><li>Ability to make decisions with a general understanding of procedures and company policies to achieve set results and deadlines.<\/li><li>Ability to multi-task and work under aggressive deadline pressure.<\/li><li>Ability to maintain a positive outlook when challenged with difficult or unknown problems.<\/li><li>Possess good time management skills.<\/li><\/ul>\n<p>Typical Pay Schedule (Based upon experience)<\/p>\n<p>Mechanic I - $25\/hr.<\/p>\n<ul><li>One (1) to two (2) years\u2019 experience as a hydraulic and electrical mechanic.<\/li><li>New graduates will be considered if trained on heavy equipment with hydraulics.<\/li><\/ul>\n<p>Mechanic II - $30-$40\/hr.<\/p>\n<ul><li>Three (3) to five (5) years\u2019 experience as a hydraulic and electrical mechanic.<\/li><\/ul>\n<p>Mechanic III - $40-$55\/hr. (Pay determination based on shop position or field position)<\/p>\n<ul><li>Six (6) years\u2019 experience as a hydraulic and electrical mechanic.<\/li><li>Experienced drilling support equipment, such as mud systems, generators, and compressors preferred.<\/li><li>Ability to work independently in the field without the daily support from the Maintenance Supervisor.<\/li><\/ul>\n<p>Mechanic IV - $40-65\/hr. (Pay determination based on shop position or field position)<\/p>\n<ul><li>Six (6) plus years\u2019 experience as a hydraulic and electrical mechanic or strong knowledge with the ability to complete all aspects of the field mechanic position without support from the Maintenance Supervisor.<\/li><li>Experienced drilling support equipment, such as mud systems, generators, and compressors preferred.<\/li><\/ul>","%category%":"","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/d90821018e95-mobile-drill-mine-mechanic","%breezy_id%":"d90821018e95","%breezy_friendly_id%":"d90821018e95-mobile-drill-mine-mechanic","%breezy_created_date%":"2024-09-27T13:41:05.445Z","%breezy_updated_date%":"2025-01-15T14:25:19.516Z","%_wpgmp_location_city%":"Elko","%_wpgmp_location_state%":"NV","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Elko, NV, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"40.8436459","%_wpgmp_metabox_longitude%":"-115.7526187","%rank_math_internal_links_processed%":"1"}},"id":1780,"infowindow_disable":false},{"source":"post","title":"Field Service Mechanic","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Field Service Mechanic\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Mechanic I-IV Do you want to work with the best people and equipment in the industry? Are you tired of&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/field-service-mechanic\/\" name=\"Field Service Mechanic\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Mechanic I-IV Do you want to work with the best people and equipment in the industry? Are you tired of&hellip;","address":"Phoenix, AZ, USA","location":{"lat":"33.4482266","city":"Phoenix","state":"AZ","country":"United States","lng":"-112.0776781","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/field-service-mechanic\/","zoom":19,"extra_fields":{"post_excerpt":"Mechanic I-IV Do you want to work with the best people and equipment in the industry? Are you tired of&hellip;","post_content":"<p><strong>Mechanic I-IV<\/strong><\/p>\n<p>Do you want to work with the best people and equipment in the industry? Are you tired of not having the parts and support needed to do your job? We offer clean, modern workspaces, fully stocked parts rooms, advanced repair and fabrication equipment, and knowledgeable, supportive leadership that will help you progress in your career.<\/p>\n<p>Our greatest asset is our team of hardworking professionals \u2013 especially our reliable and experienced maintenance crews. If you value integrity, an honest day\u2019s work, and professionalism, you will feel right at home.<\/p>\n<p>In addition to respect and appreciation for a job well done, we offer industry-leading equipment, monthly tooling allowance, competitive compensation, and travel per diem paired with a comprehensive Employee Benefit Program, including things like company-paid insurance premiums (where we pay 100% of the employee-only insurance premiums), 401(k) match, and paid time off.  <\/p>\n<p>Position Overview<\/p>\n<p>We are currently hiring experienced, full-time, hourly shop and field mechanics.  These positions diagnose, adjust, repair, fabricate, and overhaul mobile mechanical, hydraulic, and pneumatic parts, and equipment\/vehicles. Excellent welding and fabricating experience preferred.<\/p>\n<ul>\n <li>For      field mechanics, travel is required.<\/li>\n <li>Mechanics can      work a 10 days on\/4 days off, or 9 days on\/5 days off schedule. <\/li>\n<\/ul>\n<p>Essential Functions<\/p>\n<ul>\n <li>Demonstrate      a strong commitment to safe work practices and procedures.<\/li>\n <li>Repair      and replace damaged or worn parts.<\/li>\n <li>Operate      and inspect machines or heavy equipment to diagnose defects.<\/li>\n <li>Diagnose      faults or malfunctions to determine required repairs, using engine      diagnostic equipment such as computerized test equipment and calibration      devices.<\/li>\n <li>Dismantle      and reassemble heavy equipment using hoists and hand tools.<\/li>\n <li>Clean,      lubricate, and perform other routine maintenance work on equipment and      vehicles.<\/li>\n <li>Examine      parts for damage or excessive wear using micrometers and gauges.<\/li>\n <li>Schedule      maintenance for industrial machines and equipment and keep equipment      service records.<\/li>\n <li>Read      and understand operating manuals, blueprints, and technical drawings.<\/li>\n <li>Weld      or solder broken parts and structural members using electric or gas      welders and soldering tools.<\/li>\n <li>Fabricate      needed parts or items as required.<\/li>\n <li>Exhibit      a strong work ethic with the drive and desire to learn and perform tasks      efficiently. <\/li>\n <li>Maintain      effective and collaborative workplace relationships, treating others with      dignity and respect.<\/li>\n<\/ul>\n<p>Qualifications<\/p>\n<ul>\n <li>Must      pass a pre-employment physical, drug (including the use of marijuana) and      alcohol screening, Motor Vehicle Report (MVR), and additional background      screening as required by regulation and\/or industry practice. <\/li>\n <li>Must      have a valid driver's license. <\/li>\n <li>Must      be willing to travel and work in remote locations, outside, and in all      weather conditions (heat and cold)<\/li>\n <li>Experience      repairing and maintaining mechanical equipment.<\/li>\n <li>Experience      running, maneuvering, navigating, or driving vehicles or mechanized      equipment, such as forklifts, passenger and heavy equipment, and vehicles.<\/li>\n <li>Experience      analyzing information and evaluating results to choose the best solution      and solve problems.<\/li>\n <li>Experience      inspecting equipment, structures, or materials to identify the cause of      errors or other problems or defects.<\/li>\n <li>Ability      to understand and carry out general instructions in standard situations.<\/li>\n <li>Ability      to make decisions with a general understanding of procedures and company      policies to achieve set results and deadlines.<\/li>\n <li>Ability      to multi-task and work under aggressive deadline pressure.<\/li>\n <li>Ability      to maintain a positive outlook when challenged with difficult or unknown      problems.<\/li>\n <li>Possess      good time management skills.<\/li>\n<\/ul>\n<p>Typical Pay Schedule (Based upon experience)<\/p>\n<p>Mechanic I - $25\/hr.<\/p>\n<ul>\n <li>One      (1) to two (2) years\u2019 experience as a hydraulic and electrical mechanic. <\/li>\n <li>New      graduates will be considered if trained on heavy equipment with      hydraulics. <\/li>\n<\/ul>\n<p>Mechanic II - $30-$40\/hr.<\/p>\n<ul>\n <li>Three (3) to five (5) years\u2019 experience as a      hydraulic and electrical mechanic.<\/li>\n<\/ul>\n<p>Mechanic III - $40-$55\/hr. (Pay determination based on shop position or field position)<\/p>\n<ul>\n <li>Six      (6) years\u2019 experience as a hydraulic and electrical mechanic. <\/li>\n <li>Experienced      drilling support equipment, such as mud systems, generators, and      compressors preferred.<\/li>\n <li>Ability      to work independently in the field without the daily support from the      Maintenance Supervisor.<\/li>\n<\/ul>\n<p>Mechanic IV - $40-65\/hr. (Pay determination based on shop position or field position)<\/p>\n<ul>\n <li>Six      (6) plus years\u2019 experience as a hydraulic and electrical mechanic or      strong knowledge with the ability to complete all aspects of the field      mechanic position without support from the Maintenance Supervisor. <\/li>\n <li>Experienced      drilling support equipment, such as mud systems, generators, and      compressors preferred.<\/li>\n<\/ul>","post_title":"Field Service Mechanic","post_link":"https:\/\/turnerstaffing.com\/position\/field-service-mechanic\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"","%location_country%":"United States","%location_city%":"Phoenix","%location_state_id%":"AZ","%location_state_name%":"Arizona","%location_city_state%":"Phoenix, AZ","%education%":"","%department%":"","%description%":"<p><strong>Mechanic I-IV<\/strong><\/p>\n<p>Do you want to work with the best people and equipment in the industry? Are you tired of not having the parts and support needed to do your job? We offer clean, modern workspaces, fully stocked parts rooms, advanced repair and fabrication equipment, and knowledgeable, supportive leadership that will help you progress in your career.<\/p>\n<p>Our greatest asset is our team of hardworking professionals \u2013 especially our reliable and experienced maintenance crews. If you value integrity, an honest day\u2019s work, and professionalism, you will feel right at home.<\/p>\n<p>In addition to respect and appreciation for a job well done, we offer industry-leading equipment, monthly tooling allowance, competitive compensation, and travel per diem paired with a comprehensive Employee Benefit Program, including things like company-paid insurance premiums (where we pay 100% of the employee-only insurance premiums), 401(k) match, and paid time off.  <\/p>\n<p>Position Overview<\/p>\n<p>We are currently hiring experienced, full-time, hourly shop and field mechanics.  These positions diagnose, adjust, repair, fabricate, and overhaul mobile mechanical, hydraulic, and pneumatic parts, and equipment\/vehicles. Excellent welding and fabricating experience preferred.<\/p>\n<ul>\n <li>For      field mechanics, travel is required.<\/li>\n <li>Mechanics can      work a 10 days on\/4 days off, or 9 days on\/5 days off schedule. <\/li>\n<\/ul>\n<p>Essential Functions<\/p>\n<ul>\n <li>Demonstrate      a strong commitment to safe work practices and procedures.<\/li>\n <li>Repair      and replace damaged or worn parts.<\/li>\n <li>Operate      and inspect machines or heavy equipment to diagnose defects.<\/li>\n <li>Diagnose      faults or malfunctions to determine required repairs, using engine      diagnostic equipment such as computerized test equipment and calibration      devices.<\/li>\n <li>Dismantle      and reassemble heavy equipment using hoists and hand tools.<\/li>\n <li>Clean,      lubricate, and perform other routine maintenance work on equipment and      vehicles.<\/li>\n <li>Examine      parts for damage or excessive wear using micrometers and gauges.<\/li>\n <li>Schedule      maintenance for industrial machines and equipment and keep equipment      service records.<\/li>\n <li>Read      and understand operating manuals, blueprints, and technical drawings.<\/li>\n <li>Weld      or solder broken parts and structural members using electric or gas      welders and soldering tools.<\/li>\n <li>Fabricate      needed parts or items as required.<\/li>\n <li>Exhibit      a strong work ethic with the drive and desire to learn and perform tasks      efficiently. <\/li>\n <li>Maintain      effective and collaborative workplace relationships, treating others with      dignity and respect.<\/li>\n<\/ul>\n<p>Qualifications<\/p>\n<ul>\n <li>Must      pass a pre-employment physical, drug (including the use of marijuana) and      alcohol screening, Motor Vehicle Report (MVR), and additional background      screening as required by regulation and\/or industry practice. <\/li>\n <li>Must      have a valid driver's license. <\/li>\n <li>Must      be willing to travel and work in remote locations, outside, and in all      weather conditions (heat and cold)<\/li>\n <li>Experience      repairing and maintaining mechanical equipment.<\/li>\n <li>Experience      running, maneuvering, navigating, or driving vehicles or mechanized      equipment, such as forklifts, passenger and heavy equipment, and vehicles.<\/li>\n <li>Experience      analyzing information and evaluating results to choose the best solution      and solve problems.<\/li>\n <li>Experience      inspecting equipment, structures, or materials to identify the cause of      errors or other problems or defects.<\/li>\n <li>Ability      to understand and carry out general instructions in standard situations.<\/li>\n <li>Ability      to make decisions with a general understanding of procedures and company      policies to achieve set results and deadlines.<\/li>\n <li>Ability      to multi-task and work under aggressive deadline pressure.<\/li>\n <li>Ability      to maintain a positive outlook when challenged with difficult or unknown      problems.<\/li>\n <li>Possess      good time management skills.<\/li>\n<\/ul>\n<p>Typical Pay Schedule (Based upon experience)<\/p>\n<p>Mechanic I - $25\/hr.<\/p>\n<ul>\n <li>One      (1) to two (2) years\u2019 experience as a hydraulic and electrical mechanic. <\/li>\n <li>New      graduates will be considered if trained on heavy equipment with      hydraulics. <\/li>\n<\/ul>\n<p>Mechanic II - $30-$40\/hr.<\/p>\n<ul>\n <li>Three (3) to five (5) years\u2019 experience as a      hydraulic and electrical mechanic.<\/li>\n<\/ul>\n<p>Mechanic III - $40-$55\/hr. (Pay determination based on shop position or field position)<\/p>\n<ul>\n <li>Six      (6) years\u2019 experience as a hydraulic and electrical mechanic. <\/li>\n <li>Experienced      drilling support equipment, such as mud systems, generators, and      compressors preferred.<\/li>\n <li>Ability      to work independently in the field without the daily support from the      Maintenance Supervisor.<\/li>\n<\/ul>\n<p>Mechanic IV - $40-65\/hr. (Pay determination based on shop position or field position)<\/p>\n<ul>\n <li>Six      (6) plus years\u2019 experience as a hydraulic and electrical mechanic or      strong knowledge with the ability to complete all aspects of the field      mechanic position without support from the Maintenance Supervisor. <\/li>\n <li>Experienced      drilling support equipment, such as mud systems, generators, and      compressors preferred.<\/li>\n<\/ul>","%category%":"","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/dc2c4e8acbff-field-service-mechanic","%breezy_id%":"dc2c4e8acbff","%breezy_friendly_id%":"dc2c4e8acbff-field-service-mechanic","%breezy_created_date%":"2024-09-16T18:59:19.280Z","%breezy_updated_date%":"2025-01-15T13:40:24.476Z","%_wpgmp_location_city%":"Phoenix","%_wpgmp_location_state%":"AZ","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Phoenix, AZ, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"33.4482266","%_wpgmp_metabox_longitude%":"-112.0776781","%rank_math_internal_links_processed%":"1"}},"id":1735,"infowindow_disable":false},{"source":"post","title":"Field Service Technician &#8211; Mining","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Field Service Technician &#8211; Mining\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Turner Staffing Group &#8211; Heavy Equipment Mechanic Turner Staffing Group is committed to changing the way mining companies do business.&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/field-service-technician-mining-2\/\" name=\"Field Service Technician &#8211; Mining\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Turner Staffing Group &#8211; Heavy Equipment Mechanic Turner Staffing Group is committed to changing the way mining companies do business.&hellip;","address":"Phoenix, AZ, USA","location":{"lat":"33.4482266","city":"Phoenix","state":"AZ","country":"United States","lng":"-112.0776781","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/field-service-technician-mining-2\/","zoom":19,"extra_fields":{"post_excerpt":"Turner Staffing Group &#8211; Heavy Equipment Mechanic Turner Staffing Group is committed to changing the way mining companies do business.&hellip;","post_content":"<p><strong><u>Turner Staffing Group - Heavy Equipment Mechanic<\/u><\/strong><br><\/p>\n<p style=\"color:#000000\"><span style=\"color:#333333\">Turner Staffing Group is committed to changing the way mining companies do business. We develop our people. We partner with our clients. We believe in win, win, win.<\/span><\/p>\n<p>We are looking for a dynamic and talented professional to fill a Heavy Equipment Mechanic role at our fast-growing, forward thinking mining services company.&nbsp;This is an opportunity to work as part of the operations team in a safe, productive, and fun environment.<span style=\"color:#333333\"><\/span><\/p>\n\n\n\n\n\n\n<p><strong>Position Description<\/strong><\/p>\n<p>The&nbsp;Mechanic is a full-time, hourly status classification.&nbsp; This position diagnoses, adjusts, repairs, fabricates, and\/or overhauls mobile mechanical, hydraulic, and pneumatic parts, equipment\/vehicles. Prefer candidates with excellent welding and fabricating experience. Travel is required.<span style=\"color:#333333\"><\/span><\/p>\n\n<p><strong>Essential Skills &amp; Knowledge<\/strong><\/p>\n<ul><li>Repair and replace damaged or worn parts<\/li><li>Operate and inspect machines or heavy equipment in order to diagnose defects<\/li><li>Diagnose faults or malfunctions to determine required repairs, using engine diagnostic equipment such as computerized test equipment and calibration devices<\/li><li>Dismantle and reassemble heavy equipment using hoists and hand tools<\/li><li>Clean, lubricate, and perform other routine maintenance work on equipment and vehicles<\/li><li>Examine parts for damage or excessive wear using micrometers and gauges<\/li><li>Schedule maintenance for industrial machines and equipment and keep equipment service records<\/li><li>Read and understand operating manuals, blueprints, and technical drawings<\/li><li>Weld or solder broken parts and structural members using electric or gas welders and soldering tools<\/li><li>Fabricate needed parts or items as required<\/li><li>Performs other related duties as required and assigned<\/li><\/ul>\n\n<p><strong>Benefits<\/strong><\/p>\n<p style=\"color:#000000\"><span style=\"color:#333333\">Turner Staffing Group&nbsp;offers a competitive salary, an excellent work culture, career advancement opportunities. Our team offers a benefits program which includes Medical, Dental, Vision, Life, and a 401k with company match. We believe in a work life balance and established paid time off for major holidays.<\/span><span style=\"color:#333333\"><\/span><\/p>\n\n<p>At Turner Staffing Group, we encourage and celebrate an inclusive environment for all employees and are proud to be an equal opportunity workplace and affirmative action employer.<\/p>","post_title":"Field Service Technician &#8211; Mining","post_link":"https:\/\/turnerstaffing.com\/position\/field-service-technician-mining-2\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Associate","%location_country%":"United States","%location_city%":"Phoenix","%location_state_id%":"AZ","%location_state_name%":"Arizona","%location_city_state%":"Phoenix, AZ","%education%":"Unspecified","%department%":"Operations","%description%":"<p><strong><u>Turner Staffing Group - Heavy Equipment Mechanic<\/u><\/strong><br><\/p>\n<p style=\"color:#000000;\"><span style=\"color:#333333;\">Turner Staffing Group is committed to changing the way mining companies do business. We develop our people. We partner with our clients. We believe in win, win, win.<\/span><\/p>\n<p>We are looking for a dynamic and talented professional to fill a Heavy Equipment Mechanic role at our fast-growing, forward thinking mining services company.&nbsp;This is an opportunity to work as part of the operations team in a safe, productive, and fun environment.<span style=\"color:#333333;\"><\/span><\/p>\n\n\n\n\n\n\n<p><strong>Position Description<\/strong><\/p>\n<p>The&nbsp;Mechanic is a full-time, hourly status classification.&nbsp; This position diagnoses, adjusts, repairs, fabricates, and\/or overhauls mobile mechanical, hydraulic, and pneumatic parts, equipment\/vehicles. Prefer candidates with excellent welding and fabricating experience. Travel is required.<span style=\"color:#333333;\"><\/span><\/p>\n\n<p><strong>Essential Skills &amp; Knowledge<\/strong><\/p>\n<ul><li>Repair and replace damaged or worn parts<\/li><li>Operate and inspect machines or heavy equipment in order to diagnose defects<\/li><li>Diagnose faults or malfunctions to determine required repairs, using engine diagnostic equipment such as computerized test equipment and calibration devices<\/li><li>Dismantle and reassemble heavy equipment using hoists and hand tools<\/li><li>Clean, lubricate, and perform other routine maintenance work on equipment and vehicles<\/li><li>Examine parts for damage or excessive wear using micrometers and gauges<\/li><li>Schedule maintenance for industrial machines and equipment and keep equipment service records<\/li><li>Read and understand operating manuals, blueprints, and technical drawings<\/li><li>Weld or solder broken parts and structural members using electric or gas welders and soldering tools<\/li><li>Fabricate needed parts or items as required<\/li><li>Performs other related duties as required and assigned<\/li><\/ul>\n\n<p><strong>Benefits<\/strong><\/p>\n<p style=\"color:#000000;\"><span style=\"color:#333333;\">Turner Staffing Group&nbsp;offers a competitive salary, an excellent work culture, career advancement opportunities. Our team offers a benefits program which includes Medical, Dental, Vision, Life, and a 401k with company match. We believe in a work life balance and established paid time off for major holidays.<\/span><span style=\"color:#333333;\"><\/span><\/p>\n\n<p>At Turner Staffing Group, we encourage and celebrate an inclusive environment for all employees and are proud to be an equal opportunity workplace and affirmative action employer.<\/p>","%category%":"Operations","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/066af176e0a7-field-service-technician-mining","%breezy_id%":"066af176e0a7","%breezy_friendly_id%":"066af176e0a7-field-service-technician-mining","%breezy_created_date%":"2024-08-27T16:00:18.711Z","%breezy_updated_date%":"2025-02-19T16:09:23.238Z","%_wpgmp_location_city%":"Phoenix","%_wpgmp_location_state%":"AZ","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Phoenix, AZ, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"33.4482266","%_wpgmp_metabox_longitude%":"-112.0776781","%rank_math_internal_links_processed%":"1"}},"id":1698,"infowindow_disable":false},{"source":"post","title":"Field Service Technician &#8211; Mining","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Field Service Technician &#8211; Mining\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Turner Staffing Group &#8211; Heavy Equipment Mechanic Turner Staffing Group is committed to changing the way mining companies do business.&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/field-service-technician-mining\/\" name=\"Field Service Technician &#8211; Mining\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Turner Staffing Group &#8211; Heavy Equipment Mechanic Turner Staffing Group is committed to changing the way mining companies do business.&hellip;","address":"Elko, NV, USA","location":{"lat":"40.8436459","city":"Elko","state":"NV","country":"United States","lng":"-115.7526187","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/field-service-technician-mining\/","zoom":19,"extra_fields":{"post_excerpt":"Turner Staffing Group &#8211; Heavy Equipment Mechanic Turner Staffing Group is committed to changing the way mining companies do business.&hellip;","post_content":"<p><strong><u>Turner Staffing Group - Heavy Equipment Mechanic<\/u><\/strong><br><\/p>\n<p style=\"color:#000000\"><span style=\"color:#333333\">Turner Staffing Group is committed to changing the way mining companies do business. We develop our people. We partner with our clients. We believe in win, win, win.<\/span><\/p>\n<p>We are looking for a dynamic and talented professional to fill a Heavy Equipment Mechanic role at our fast-growing, forward thinking mining services company.<\/p>\n<p style=\"color:#000000\"><span style=\"color:#333333\">Turner Staffing Group is seeking an energetic professional who can leverage their Heavy Equipment knowledge to expand upon our fast-growing business, creating best practices for systems and scalable business processes to ensure profitable operations. <\/span><\/p>\n<p><\/p>\n<p>This person will function as a Heavy Equipment Mechanic, willingness to do, learn, perform and improve any maintenance task. <\/p>\n<p><\/p>\n<p>Tasks will be defined and evolve in all areas of mining operations to ensure preventative maintenance is practiced, repairs, equipment runs in the area of responsibility. You will report to and work with the Project Superintendent to develop heavy equipment procedures that will ensure safe operations. <\/p>\n<p><\/p>\n<p>This is an opportunity to work as part of the operations team in a safe, productive, and fun environment.<\/p>\n<p style=\"color:#000000\"><span style=\"color:#333333\"> <\/span><\/p>\n<p><strong>Position Description<\/strong><\/p>\n<p>The Mechanic is a full-time, hourly status classification.&nbsp; This position diagnoses, adjusts, repairs, fabricates, and\/or overhauls mobile mechanical, hydraulic, and pneumatic parts, equipment\/vehicles. Prefer candidates with excellent welding and fabricating experience. Travel is required.<strong><br><\/strong><br><\/p>\n<p style=\"color:#000000\"><span style=\"color:#333333\"> <\/span><\/p>\n<p><strong>Essential Skills &amp; Knowledge<\/strong><\/p>\n<ul><li>Repair and replace damaged or worn parts<\/li><li>Operate and inspect machines or heavy equipment in order to diagnose defects<\/li><li>Diagnose faults or malfunctions to determine required repairs, using engine diagnostic equipment such as computerized test equipment and calibration devices<\/li><li>Dismantle and reassemble heavy equipment using hoists and hand tools<\/li><li>Clean, lubricate, and perform other routine maintenance work on equipment and vehicles<\/li><li>Examine parts for damage or excessive wear using micrometers and gauges<\/li><li>Schedule maintenance for industrial machines and equipment and keep equipment service records<\/li><li>Read and understand operating manuals, blueprints, and technical drawings<\/li><li>Weld or solder broken parts and structural members using electric or gas welders and soldering tools<\/li><li>Fabricate needed parts or items as required<\/li><li>Performs other related duties as required and assigned<\/li><\/ul>\n<p style=\"color:#000000\"><br><\/p>\n<p style=\"color:#000000\"><span style=\"color:#333333\"> <\/span><\/p>\n<p><strong>Benefits<\/strong><\/p>\n<p style=\"color:#000000\"><span style=\"color:#333333\">Turner Staffing Group&nbsp;offers a competitive salary, an excellent work culture, career advancement opportunities. Our team offers a benefits program which includes Medical, Dental, Vision, Life, and a 401k with company match. We believe in a work life balance and established paid time off for major holidays.<\/span><\/p>\n<p style=\"color:#000000\"><span style=\"color:#333333\"> <\/span><\/p>\n<p>At Turner Staffing Group, we encourage and celebrate an inclusive environment for all employees and are proud to be an equal opportunity workplace and affirmative action employer.<\/p>","post_title":"Field Service Technician &#8211; Mining","post_link":"https:\/\/turnerstaffing.com\/position\/field-service-technician-mining\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"","%location_country%":"United States","%location_city%":"Elko","%location_state_id%":"NV","%location_state_name%":"Nevada","%location_city_state%":"Elko, NV","%education%":"","%department%":"Equipment","%description%":"<p><strong><u>Turner Staffing Group - Heavy Equipment Mechanic<\/u><\/strong><br><\/p>\n<p style=\"color:#000000;\"><span style=\"color:#333333;\">Turner Staffing Group is committed to changing the way mining companies do business. We develop our people. We partner with our clients. We believe in win, win, win.<\/span><\/p>\n<p>We are looking for a dynamic and talented professional to fill a Heavy Equipment Mechanic role at our fast-growing, forward thinking mining services company.<\/p>\n<p style=\"color:#000000;\"><span style=\"color:#333333;\">Turner Staffing Group is seeking an energetic professional who can leverage their Heavy Equipment knowledge to expand upon our fast-growing business, creating best practices for systems and scalable business processes to ensure profitable operations. <\/span><\/p>\n<p><\/p>\n<p>This person will function as a Heavy Equipment Mechanic, willingness to do, learn, perform and improve any maintenance task. <\/p>\n<p><\/p>\n<p>Tasks will be defined and evolve in all areas of mining operations to ensure preventative maintenance is practiced, repairs, equipment runs in the area of responsibility. You will report to and work with the Project Superintendent to develop heavy equipment procedures that will ensure safe operations. <\/p>\n<p><\/p>\n<p>This is an opportunity to work as part of the operations team in a safe, productive, and fun environment.<\/p>\n<p style=\"color:#000000;\"><span style=\"color:#333333;\"> <\/span><\/p>\n<p><strong>Position Description<\/strong><\/p>\n<p>The Mechanic is a full-time, hourly status classification.&nbsp; This position diagnoses, adjusts, repairs, fabricates, and\/or overhauls mobile mechanical, hydraulic, and pneumatic parts, equipment\/vehicles. Prefer candidates with excellent welding and fabricating experience. Travel is required.<strong><br><\/strong><br><\/p>\n<p style=\"color:#000000;\"><span style=\"color:#333333;\"> <\/span><\/p>\n<p><strong>Essential Skills &amp; Knowledge<\/strong><\/p>\n<ul><li>Repair and replace damaged or worn parts<\/li><li>Operate and inspect machines or heavy equipment in order to diagnose defects<\/li><li>Diagnose faults or malfunctions to determine required repairs, using engine diagnostic equipment such as computerized test equipment and calibration devices<\/li><li>Dismantle and reassemble heavy equipment using hoists and hand tools<\/li><li>Clean, lubricate, and perform other routine maintenance work on equipment and vehicles<\/li><li>Examine parts for damage or excessive wear using micrometers and gauges<\/li><li>Schedule maintenance for industrial machines and equipment and keep equipment service records<\/li><li>Read and understand operating manuals, blueprints, and technical drawings<\/li><li>Weld or solder broken parts and structural members using electric or gas welders and soldering tools<\/li><li>Fabricate needed parts or items as required<\/li><li>Performs other related duties as required and assigned<\/li><\/ul>\n<p style=\"color:#000000;\"><br><\/p>\n<p style=\"color:#000000;\"><span style=\"color:#333333;\"> <\/span><\/p>\n<p><strong>Benefits<\/strong><\/p>\n<p style=\"color:#000000;\"><span style=\"color:#333333;\">Turner Staffing Group&nbsp;offers a competitive salary, an excellent work culture, career advancement opportunities. Our team offers a benefits program which includes Medical, Dental, Vision, Life, and a 401k with company match. We believe in a work life balance and established paid time off for major holidays.<\/span><\/p>\n<p style=\"color:#000000;\"><span style=\"color:#333333;\"> <\/span><\/p>\n<p>At Turner Staffing Group, we encourage and celebrate an inclusive environment for all employees and are proud to be an equal opportunity workplace and affirmative action employer.<\/p>","%category%":"Other","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/f3dfde960edc-field-service-technician-mining","%breezy_id%":"f3dfde960edc","%breezy_friendly_id%":"f3dfde960edc-field-service-technician-mining","%breezy_created_date%":"2023-04-20T16:57:18.967Z","%breezy_updated_date%":"2025-01-15T13:40:16.482Z","%_wpgmp_location_city%":"Elko","%_wpgmp_location_state%":"NV","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Elko, NV, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"40.8436459","%_wpgmp_metabox_longitude%":"-115.7526187","%rank_math_internal_links_processed%":"1"}},"id":1695,"infowindow_disable":false},{"source":"post","title":"Mining Maintenance Mechanic","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Mining Maintenance Mechanic\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Maintenance Mechanic&nbsp; Job Description: Repairs and maintains plant equipment as assigned, including electric and gas welding, hydraulics, rigging, pipe fitting,pumps,&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/mining-maintenance-mechanic\/\" name=\"Mining Maintenance Mechanic\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Maintenance Mechanic&nbsp; Job Description: Repairs and maintains plant equipment as assigned, including electric and gas welding, hydraulics, rigging, pipe fitting,pumps,&hellip;","address":"Ely, NV, USA","location":{"lat":"39.2533328","city":"Ely","state":"NV","country":"United States","lng":"-114.874248","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/mining-maintenance-mechanic\/","zoom":19,"extra_fields":{"post_excerpt":"Maintenance Mechanic&nbsp; Job Description: Repairs and maintains plant equipment as assigned, including electric and gas welding, hydraulics, rigging, pipe fitting,pumps,&hellip;","post_content":"<p>Maintenance Mechanic&nbsp;<\/p>\n<p>Job Description:<\/p>\n<p>Repairs and maintains plant equipment as assigned, including electric and gas welding, hydraulics, rigging, pipe fitting,<br>pumps, air compressors, vacuum pumps, bearings and seals, power transmissions, gear boxes, equipment settings and<br>alignment.<\/p>\n<p>Job Requirements:<\/p>\n<p>Must have a minimum set of hand tools as specified by the Company. Previous experience must include a minimum of four<br>years as a millwright.<br>Job includes but is not limited to: repair of conveyor belts, bucket elevators, crushers, ball mills, screens, pumps, etc.<br>Experience in industrial construction and\/or repair may count. Must be able to read and understand blueprints and equipment<br>instructions. Must be able to weld with enough proficiency to pass a Company welding test in both electrical arc and<br>oxygen\/acetylene welding and understand the safe handling of welding equipment. Must be able to determine what type of<br>rod to use on different types of steel and cast iron. Must be thoroughly familiar with all aspects of safety in the maintenance<br>field. Must be capable of working with a minimum of supervision. Must be able to work all shifts. A written test will be<br>given as part of the company\u2019s evaluation of aptitude for the job. All work described above to be done in an efficient and<br>workman-like manner. This position is subject to duties as assigned.<br>This position is subject to shift work.<br>Additional :<br>Job requires a thorough knowledge of the load bearing capabilities of the equipment used as well as an understanding of<br>blueprints and technical instructions. Primary purpose of installing, maintaining, upgrading, and fabricating machinery and<br>equipment according to layout plans, blueprints, and other drawings in industrial establishment.<br>Typical duties include:<br>\uf0b7Read blueprints and schematic drawings to determine work procedures. Dismantle machinery or equipment, using hammers,<br>wrenches, crowbars, and other hand tools.<br>\uf0b7Moves machinery and equipment, using hoists, dollies, rollers, and trucks.<br>\uf0b7Assembles and installs equipment, such as shafting, conveyors, and tram rails, using hand tools and power tools.<br>\uf0b7Constructs foundation for machines, using hand tools and building materials, such as wood cement, and steel.<br>\uf0b7Align machines and equipment, using hoists, jacks, hand tools, squares, rules, micrometers, lasers, and plumb bobs.<br>\uf0b7Assembles machinery and bolts, welds, rivets, or otherwise fastens them to foundation or other structures, using hand tools<br>and power tools.<br>\uf0b7May operate engine lathe or milling machine to grind, file, and turn machine parts to dimensional specifications.<br>\uf0b7Required repair and lubricate machinery and equipment.<br>\uf0b7Selects cables, ropes, chains, pulleys, winches, blocks, and sheaves, according to weight and size of load to be moved.<br>\uf0b7Attaches load with grappling devices, such as loops, wires, ropes, and chains, to crane hook.<br>\uf0b7Sets up, braces, and rigs hoisting equipment, using hand tools and power wrenches.<br>\uf0b7May direct workers engaged in hoisting of machinery and equipment.<\/p>","post_title":"Mining Maintenance Mechanic","post_link":"https:\/\/turnerstaffing.com\/position\/mining-maintenance-mechanic\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"","%location_country%":"United States","%location_city%":"Ely","%location_state_id%":"NV","%location_state_name%":"Nevada","%location_city_state%":"Ely, NV","%education%":"","%department%":"","%description%":"<p>Maintenance Mechanic&nbsp;<\/p>\n<p>Job Description:<\/p>\n<p>Repairs and maintains plant equipment as assigned, including electric and gas welding, hydraulics, rigging, pipe fitting,<br>pumps, air compressors, vacuum pumps, bearings and seals, power transmissions, gear boxes, equipment settings and<br>alignment.<\/p>\n<p>Job Requirements:<\/p>\n<p>Must have a minimum set of hand tools as specified by the Company. Previous experience must include a minimum of four<br>years as a millwright.<br>Job includes but is not limited to: repair of conveyor belts, bucket elevators, crushers, ball mills, screens, pumps, etc.<br>Experience in industrial construction and\/or repair may count. Must be able to read and understand blueprints and equipment<br>instructions. Must be able to weld with enough proficiency to pass a Company welding test in both electrical arc and<br>oxygen\/acetylene welding and understand the safe handling of welding equipment. Must be able to determine what type of<br>rod to use on different types of steel and cast iron. Must be thoroughly familiar with all aspects of safety in the maintenance<br>field. Must be capable of working with a minimum of supervision. Must be able to work all shifts. A written test will be<br>given as part of the company\u2019s evaluation of aptitude for the job. All work described above to be done in an efficient and<br>workman-like manner. This position is subject to duties as assigned.<br>This position is subject to shift work.<br>Additional :<br>Job requires a thorough knowledge of the load bearing capabilities of the equipment used as well as an understanding of<br>blueprints and technical instructions. Primary purpose of installing, maintaining, upgrading, and fabricating machinery and<br>equipment according to layout plans, blueprints, and other drawings in industrial establishment.<br>Typical duties include:<br>\uf0b7Read blueprints and schematic drawings to determine work procedures. Dismantle machinery or equipment, using hammers,<br>wrenches, crowbars, and other hand tools.<br>\uf0b7Moves machinery and equipment, using hoists, dollies, rollers, and trucks.<br>\uf0b7Assembles and installs equipment, such as shafting, conveyors, and tram rails, using hand tools and power tools.<br>\uf0b7Constructs foundation for machines, using hand tools and building materials, such as wood cement, and steel.<br>\uf0b7Align machines and equipment, using hoists, jacks, hand tools, squares, rules, micrometers, lasers, and plumb bobs.<br>\uf0b7Assembles machinery and bolts, welds, rivets, or otherwise fastens them to foundation or other structures, using hand tools<br>and power tools.<br>\uf0b7May operate engine lathe or milling machine to grind, file, and turn machine parts to dimensional specifications.<br>\uf0b7Required repair and lubricate machinery and equipment.<br>\uf0b7Selects cables, ropes, chains, pulleys, winches, blocks, and sheaves, according to weight and size of load to be moved.<br>\uf0b7Attaches load with grappling devices, such as loops, wires, ropes, and chains, to crane hook.<br>\uf0b7Sets up, braces, and rigs hoisting equipment, using hand tools and power wrenches.<br>\uf0b7May direct workers engaged in hoisting of machinery and equipment.<\/p>","%category%":"","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/94712b73663b-mining-maintenance-mechanic","%breezy_id%":"94712b73663b","%breezy_friendly_id%":"94712b73663b-mining-maintenance-mechanic","%breezy_created_date%":"2024-08-21T17:37:09.346Z","%breezy_updated_date%":"2025-01-15T14:25:22.905Z","%_wpgmp_location_city%":"Ely","%_wpgmp_location_state%":"NV","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Ely, NV, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"39.2533328","%_wpgmp_metabox_longitude%":"-114.874248","%rank_math_internal_links_processed%":"1"}},"id":1680,"infowindow_disable":false},{"source":"post","title":"Dozer Operator","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Dozer Operator\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Turner Mining Group \u2013 Heavy Equipment Operator Do you love mining? Do you think differently? Are you ready to define&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/dozer-operator\/\" name=\"Dozer Operator\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Turner Mining Group \u2013 Heavy Equipment Operator Do you love mining? Do you think differently? Are you ready to define&hellip;","address":"Kingman, AZ, USA","location":{"lat":"35.1912977","city":"Kingman","state":"AZ","country":"United States","lng":"-114.0522845","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/dozer-operator\/","zoom":19,"extra_fields":{"post_excerpt":"Turner Mining Group \u2013 Heavy Equipment Operator Do you love mining? Do you think differently? Are you ready to define&hellip;","post_content":"<p style=\"color:#000000\"><strong><span style=\"text-decoration:underline\"><span style=\"color:#555555\">Turner Mining Group \u2013 Heavy Equipment Operator<\/span><\/span><\/strong><\/p>\n<p style=\"color:#000000\"><span style=\"color:#333333\">Do you love mining? Do you think differently? Are you ready to define the future of this industry?<\/span><\/p>\n<p style=\"color:#000000\"><span style=\"color:#333333\">We\u2019ve been waiting for you! Turner Mining Group is committed to changing the way mining companies do business. We develop our people. We partner with our clients. We believe in win, win, win.<\/span><\/p>\n<p style=\"color:#000000\"><span style=\"color:#333333\">We are looking for a dynamic and talented mining Heavy Equipment Operators for our fast-growing, forward thinking mining services company headquartered in Bloomington, Indiana with our Operations team headquartered in Salt Lake City, Utah.<\/span><\/p>\n<p style=\"color:#000000\"><span style=\"color:#333333\">Turner Mining Group is seeking an energetic mining professionals who can leverage their mining knowledge to expand upon our fast-growing business, creating best practices for equipment operations to ensure profitable operations.<\/span><\/p>\n<p style=\"color:#000000\"><strong><span style=\"color:#333333\">You<\/span><\/strong><\/p>\n<p style=\"color:#000000\"><span style=\"color:#333333\">You want to work for a services company that is rapidly changing the way the largest materials producers do business. You are motivated by solving problems and partnering with our clients and suppliers. You want to work with great people and enjoy being a part of a strong team. You are a knowledgeable Operator who is not afraid to jump into every detail. You want to be in a place where continuous learning and growth is the norm. You are adaptable and able to juggle multiple initiatives concurrently.<\/span><\/p>\n<p style=\"color:#000000\"><strong><span style=\"color:#555555\">Responsibilities:<\/span><\/strong><\/p>\n<ul><li>Operating heavy equipment including blade, excavators, dozers, haul trucks, and other machines<\/li><li>Performing all pre-shift inspections, some basic maintenance and upkeep<\/li><li>Working with teammates on crew to maximize production while always maintaining our safety rules and regulations.<\/li><\/ul>\n<p style=\"color:#000000\"><strong>Requirements:<\/strong><\/p>\n<ul><li><span style=\"color:#555555\">Safety oriented, awareness of everyone and everything that is around you<\/span><\/li><li><span style=\"color:#555555\">Strong work ethic<\/span><\/li><li><span style=\"color:#555555\">Willingness to learn<\/span><\/li><li><span style=\"color:#555555\">Ability to be flexible and to adapt<\/span><\/li><li><span style=\"color:#555555\">Experience with heavy equipment<\/span><\/li><li><span style=\"color:#555555\">Preferred to have MSHA training<\/span><\/li><\/ul>\n<p><strong>Benefits:<\/strong><\/p>\n<ul><p style=\"color:#000000\"><span style=\"color:#333333\">Turner Mining Group offers a competitive salary, an excellent work culture, career advancement opportunities. Our team offers a benefits program which includes Medical, Dental, Vision, Life, and a 401k with company match.<\/span><\/p><p style=\"color:#000000\"><span style=\"color:#333333\">At Turner Mining Group, we encourage and celebrate an inclusive environment for all employees and are proud to be an equal opportunity workplace and affirmative action employer.<\/span><\/p><\/ul>","post_title":"Dozer Operator","post_link":"https:\/\/turnerstaffing.com\/position\/dozer-operator\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"","%location_country%":"United States","%location_city%":"Kingman","%location_state_id%":"AZ","%location_state_name%":"Arizona","%location_city_state%":"Kingman, AZ","%education%":"","%department%":"Construction","%description%":"<p style=\"color:#000000;\"><strong><span style=\"text-decoration:underline;\"><span style=\"color:#555555;\">Turner Mining Group \u2013 Heavy Equipment Operator<\/span><\/span><\/strong><\/p>\n<p style=\"color:#000000;\"><span style=\"color:#333333;\">Do you love mining? Do you think differently? Are you ready to define the future of this industry?<\/span><\/p>\n<p style=\"color:#000000;\"><span style=\"color:#333333;\">We\u2019ve been waiting for you! Turner Mining Group is committed to changing the way mining companies do business. We develop our people. We partner with our clients. We believe in win, win, win.<\/span><\/p>\n<p style=\"color:#000000;\"><span style=\"color:#333333;\">We are looking for a dynamic and talented mining Heavy Equipment Operators for our fast-growing, forward thinking mining services company headquartered in Bloomington, Indiana with our Operations team headquartered in Salt Lake City, Utah.<\/span><\/p>\n<p style=\"color:#000000;\"><span style=\"color:#333333;\">Turner Mining Group is seeking an energetic mining professionals who can leverage their mining knowledge to expand upon our fast-growing business, creating best practices for equipment operations to ensure profitable operations.<\/span><\/p>\n<p style=\"color:#000000;\"><strong><span style=\"color:#333333;\">You<\/span><\/strong><\/p>\n<p style=\"color:#000000;\"><span style=\"color:#333333;\">You want to work for a services company that is rapidly changing the way the largest materials producers do business. You are motivated by solving problems and partnering with our clients and suppliers. You want to work with great people and enjoy being a part of a strong team. You are a knowledgeable Operator who is not afraid to jump into every detail. You want to be in a place where continuous learning and growth is the norm. You are adaptable and able to juggle multiple initiatives concurrently.<\/span><\/p>\n<p style=\"color:#000000;\"><strong><span style=\"color:#555555;\">Responsibilities:<\/span><\/strong><\/p>\n<ul><li>Operating heavy equipment including blade, excavators, dozers, haul trucks, and other machines<\/li><li>Performing all pre-shift inspections, some basic maintenance and upkeep<\/li><li>Working with teammates on crew to maximize production while always maintaining our safety rules and regulations.<\/li><\/ul>\n<p style=\"color:#000000;\"><strong>Requirements:<\/strong><\/p>\n<ul><li><span style=\"color:#555555;\">Safety oriented, awareness of everyone and everything that is around you<\/span><\/li><li><span style=\"color:#555555;\">Strong work ethic<\/span><\/li><li><span style=\"color:#555555;\">Willingness to learn<\/span><\/li><li><span style=\"color:#555555;\">Ability to be flexible and to adapt<\/span><\/li><li><span style=\"color:#555555;\">Experience with heavy equipment<\/span><\/li><li><span style=\"color:#555555;\">Preferred to have MSHA training<\/span><\/li><\/ul>\n<p><strong>Benefits:<\/strong><\/p>\n<ul><p style=\"color:#000000;\"><span style=\"color:#333333;\">Turner Mining Group offers a competitive salary, an excellent work culture, career advancement opportunities. Our team offers a benefits program which includes Medical, Dental, Vision, Life, and a 401k with company match.<\/span><\/p><p style=\"color:#000000;\"><span style=\"color:#333333;\">At Turner Mining Group, we encourage and celebrate an inclusive environment for all employees and are proud to be an equal opportunity workplace and affirmative action employer.<\/span><\/p><\/ul>","%category%":"Operations","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/f9cd3e5e4cda-dozer-operator","%breezy_id%":"f9cd3e5e4cda","%breezy_friendly_id%":"f9cd3e5e4cda-dozer-operator","%breezy_created_date%":"2021-11-16T21:01:07.000Z","%breezy_updated_date%":"2025-02-18T15:02:45.287Z","%_wpgmp_location_city%":"Kingman","%_wpgmp_location_state%":"AZ","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Kingman, AZ, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"35.1912977","%_wpgmp_metabox_longitude%":"-114.0522845","%rank_math_internal_links_processed%":"1"}},"id":1657,"infowindow_disable":false},{"source":"post","title":"Excavator \/ Loader Operator","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Excavator \/ Loader Operator\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Turner Mining Group \u2013 Heavy Equipment Operator Do you love mining? Do you think differently? Are you ready to define&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/excavator-loader-operator\/\" name=\"Excavator \/ Loader Operator\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Turner Mining Group \u2013 Heavy Equipment Operator Do you love mining? Do you think differently? Are you ready to define&hellip;","address":"Kingman, AZ, USA","location":{"lat":"35.1912977","city":"Kingman","state":"AZ","country":"United States","lng":"-114.0522845","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/excavator-loader-operator\/","zoom":19,"extra_fields":{"post_excerpt":"Turner Mining Group \u2013 Heavy Equipment Operator Do you love mining? Do you think differently? Are you ready to define&hellip;","post_content":"<p style=\"color:#000000\"><span style=\"color:#333333\"><strong><\/strong><\/span><strong><span style=\"text-decoration:underline\"><span style=\"color:#555555\">Turner Mining Group \u2013 Heavy Equipment Operator<\/span><\/span><\/strong><\/p>\n<p style=\"color:#000000\"><span style=\"color:#333333\">Do you love mining? Do you think differently? Are you ready to define the future of this industry?<\/span><\/p>\n<p style=\"color:#000000\"><span style=\"color:#333333\">We\u2019ve been waiting for you! Turner Mining Group is committed to changing the way mining companies do business. We develop our people. We partner with our clients. We believe in win, win, win.<\/span><\/p>\n<p style=\"color:#000000\"><span style=\"color:#333333\">We are looking for a dynamic and talented mining Heavy Equipment Operators for our fast-growing, forward thinking mining services company headquartered in Bloomington, Indiana with our Operations team headquartered in Salt Lake City, Utah.<\/span><\/p>\n<p style=\"color:#000000\"><span style=\"color:#333333\">Turner Mining Group is seeking an energetic mining professionals who can leverage their mining knowledge to expand upon our fast-growing business, creating best practices for equipment operations to ensure profitable operations.<\/span><\/p>\n<p style=\"color:#000000\"><strong><span style=\"color:#333333\">You<\/span><\/strong><\/p>\n<p style=\"color:#000000\"><span style=\"color:#333333\">You want to work for a services company that is rapidly changing the way the largest materials producers do business. You are motivated by solving problems and partnering with our clients and suppliers. You want to work with great people and enjoy being a part of a strong team. You are a knowledgeable Operator who is not afraid to jump into every detail. You want to be in a place where continuous learning and growth is the norm. You are adaptable and able to juggle multiple initiatives concurrently.<\/span><\/p>\n<p style=\"color:#000000\"><strong><span style=\"color:#555555\">Responsibilities:<\/span><\/strong><\/p>\n<ul><li>Operating heavy equipment including blade, excavators, dozers, haul trucks, and other machines<\/li><li>Performing all pre-shift inspections, some basic maintenance and upkeep<\/li><li>Working with teammates on crew to maximize production while always maintaining our safety rules and regulations.<\/li><\/ul>\n<p style=\"color:#000000\"><strong>Requirements:<\/strong><\/p>\n<ul><li><span style=\"color:#555555\">Safety oriented, awareness of everyone and everything that is around you<\/span><\/li><li><span style=\"color:#555555\">Strong work ethic<\/span><\/li><li><span style=\"color:#555555\">Willingness to learn<\/span><\/li><li><span style=\"color:#555555\">Ability to be flexible and to adapt<\/span><\/li><li><span style=\"color:#555555\">Experience with heavy equipment<\/span><\/li><li><span style=\"color:#555555\">Preferred to have MSHA training<\/span><\/li><\/ul>\n<p><strong>Benefits:<\/strong><\/p>\n<ul><p style=\"color:#000000\"><span style=\"color:#333333\">Turner Mining Group offers a competitive salary, an excellent work culture, career advancement opportunities. Our team offers a benefits program which includes Medical, Dental, Vision, Life, and a 401k with company match.<\/span><\/p><p style=\"color:#000000\"><span style=\"color:#333333\">At Turner Mining Group, we encourage and celebrate an inclusive environment for all employees and are proud to be an equal opportunity workplace and affirmative action employer.<\/span><\/p><\/ul>\n<p style=\"color:#000000\"><span style=\"color:#333333\">&nbsp;<\/span><\/p>","post_title":"Excavator \/ Loader Operator","post_link":"https:\/\/turnerstaffing.com\/position\/excavator-loader-operator\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"","%location_country%":"United States","%location_city%":"Kingman","%location_state_id%":"AZ","%location_state_name%":"Arizona","%location_city_state%":"Kingman, AZ","%education%":"","%department%":"Construction","%description%":"<p style=\"color:#000000;\"><span style=\"color:#333333;\"><strong><\/strong><\/span><strong><span style=\"text-decoration:underline;\"><span style=\"color:#555555;\">Turner Mining Group \u2013 Heavy Equipment Operator<\/span><\/span><\/strong><\/p>\n<p style=\"color:#000000;\"><span style=\"color:#333333;\">Do you love mining? Do you think differently? Are you ready to define the future of this industry?<\/span><\/p>\n<p style=\"color:#000000;\"><span style=\"color:#333333;\">We\u2019ve been waiting for you! Turner Mining Group is committed to changing the way mining companies do business. We develop our people. We partner with our clients. We believe in win, win, win.<\/span><\/p>\n<p style=\"color:#000000;\"><span style=\"color:#333333;\">We are looking for a dynamic and talented mining Heavy Equipment Operators for our fast-growing, forward thinking mining services company headquartered in Bloomington, Indiana with our Operations team headquartered in Salt Lake City, Utah.<\/span><\/p>\n<p style=\"color:#000000;\"><span style=\"color:#333333;\">Turner Mining Group is seeking an energetic mining professionals who can leverage their mining knowledge to expand upon our fast-growing business, creating best practices for equipment operations to ensure profitable operations.<\/span><\/p>\n<p style=\"color:#000000;\"><strong><span style=\"color:#333333;\">You<\/span><\/strong><\/p>\n<p style=\"color:#000000;\"><span style=\"color:#333333;\">You want to work for a services company that is rapidly changing the way the largest materials producers do business. You are motivated by solving problems and partnering with our clients and suppliers. You want to work with great people and enjoy being a part of a strong team. You are a knowledgeable Operator who is not afraid to jump into every detail. You want to be in a place where continuous learning and growth is the norm. You are adaptable and able to juggle multiple initiatives concurrently.<\/span><\/p>\n<p style=\"color:#000000;\"><strong><span style=\"color:#555555;\">Responsibilities:<\/span><\/strong><\/p>\n<ul><li>Operating heavy equipment including blade, excavators, dozers, haul trucks, and other machines<\/li><li>Performing all pre-shift inspections, some basic maintenance and upkeep<\/li><li>Working with teammates on crew to maximize production while always maintaining our safety rules and regulations.<\/li><\/ul>\n<p style=\"color:#000000;\"><strong>Requirements:<\/strong><\/p>\n<ul><li><span style=\"color:#555555;\">Safety oriented, awareness of everyone and everything that is around you<\/span><\/li><li><span style=\"color:#555555;\">Strong work ethic<\/span><\/li><li><span style=\"color:#555555;\">Willingness to learn<\/span><\/li><li><span style=\"color:#555555;\">Ability to be flexible and to adapt<\/span><\/li><li><span style=\"color:#555555;\">Experience with heavy equipment<\/span><\/li><li><span style=\"color:#555555;\">Preferred to have MSHA training<\/span><\/li><\/ul>\n<p><strong>Benefits:<\/strong><\/p>\n<ul><p style=\"color:#000000;\"><span style=\"color:#333333;\">Turner Mining Group offers a competitive salary, an excellent work culture, career advancement opportunities. Our team offers a benefits program which includes Medical, Dental, Vision, Life, and a 401k with company match.<\/span><\/p><p style=\"color:#000000;\"><span style=\"color:#333333;\">At Turner Mining Group, we encourage and celebrate an inclusive environment for all employees and are proud to be an equal opportunity workplace and affirmative action employer.<\/span><\/p><\/ul>\n<p style=\"color:#000000;\"><span style=\"color:#333333;\">&nbsp;<\/span><\/p>","%category%":"Operations","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/49cabfbc3545-excavator-loader-operator","%breezy_id%":"49cabfbc3545","%breezy_friendly_id%":"49cabfbc3545-excavator-loader-operator","%breezy_created_date%":"2021-11-16T21:04:28.000Z","%breezy_updated_date%":"2025-02-18T15:06:17.328Z","%_wpgmp_location_city%":"Kingman","%_wpgmp_location_state%":"AZ","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Kingman, AZ, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"35.1912977","%_wpgmp_metabox_longitude%":"-114.0522845","%rank_math_internal_links_processed%":"1"}},"id":1630,"infowindow_disable":false},{"source":"post","title":"Heavy Equipment Mechanic (Drill\/Shovel)","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Heavy Equipment Mechanic (Drill\/Shovel)\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    This person will function as a heavy equipment mechanic and should maintain a&nbsp;willingness to do, learn, perform and improve any&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/heavy-equipment-mechanic-drill-shovel\/\" name=\"Heavy Equipment Mechanic (Drill\/Shovel)\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"This person will function as a heavy equipment mechanic and should maintain a&nbsp;willingness to do, learn, perform and improve any&hellip;","address":"Eureka Area, NV, USA","location":{"lat":"39.5124858","city":"Eureka Area","state":"NV","country":"United States","lng":"-115.9607803","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/heavy-equipment-mechanic-drill-shovel\/","zoom":19,"extra_fields":{"post_excerpt":"This person will function as a heavy equipment mechanic and should maintain a&nbsp;willingness to do, learn, perform and improve any&hellip;","post_content":"<p>This person will function as a heavy equipment mechanic and should maintain a&nbsp;willingness to do, learn, perform and improve any maintenance task. They will specifically be working on drills\/shovels.&nbsp;<\/p><p>This person should have experience with the following:<\/p><p>-Diagnostics and troubleshooting<br>-Welding<br>-3-5 years of mechanical experience<br>-Knowledge to maintain\/repair AC, hydraulic, electrical, compressed air, and powertrain systems<br>-Knowledge to maintain\/repair braking and steering systems&nbsp;<br>-Knowledge to maintain\/repair engine overheads and procedures<br>-Lifting and rigging<\/p><p><br><\/p><p><\/p><p><\/p>","post_title":"Heavy Equipment Mechanic (Drill\/Shovel)","post_link":"https:\/\/turnerstaffing.com\/position\/heavy-equipment-mechanic-drill-shovel\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"","%location_country%":"United States","%location_city%":"Eureka Area","%location_state_id%":"NV","%location_state_name%":"Nevada","%location_city_state%":"Eureka Area, NV","%education%":"","%department%":"","%description%":"<p>This person will function as a heavy equipment mechanic and should maintain a&nbsp;willingness to do, learn, perform and improve any maintenance task. They will specifically be working on drills\/shovels.&nbsp;<\/p><p>This person should have experience with the following:<\/p><p>-Diagnostics and troubleshooting<br>-Welding<br>-3-5 years of mechanical experience<br>-Knowledge to maintain\/repair AC, hydraulic, electrical, compressed air, and powertrain systems<br>-Knowledge to maintain\/repair braking and steering systems&nbsp;<br>-Knowledge to maintain\/repair engine overheads and procedures<br>-Lifting and rigging<\/p><p><br><\/p><p><\/p><p><\/p>","%category%":"","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/c94002623d85-heavy-equipment-mechanic-drill-shovel","%breezy_id%":"c94002623d85","%breezy_friendly_id%":"c94002623d85-heavy-equipment-mechanic-drill-shovel","%breezy_created_date%":"2024-07-17T19:26:24.259Z","%breezy_updated_date%":"2025-01-29T21:18:35.961Z","%_wpgmp_location_city%":"Eureka Area","%_wpgmp_location_state%":"NV","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Eureka Area, NV, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"39.5124858","%_wpgmp_metabox_longitude%":"-115.9607803","%rank_math_internal_links_processed%":"1"}},"id":1588,"infowindow_disable":false},{"source":"post","title":"Heavy Equipment Mechanic","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Heavy Equipment Mechanic\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    This person will function as a heavy equipment mechanic and should maintain a willingness to do, learn, perform and improve&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/heavy-equipment-mechanic-5\/\" name=\"Heavy Equipment Mechanic\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"This person will function as a heavy equipment mechanic and should maintain a willingness to do, learn, perform and improve&hellip;","address":"Eureka Area, NV, USA","location":{"lat":"39.5124858","city":"Eureka Area","state":"NV","country":"United States","lng":"-115.9607803","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/heavy-equipment-mechanic-5\/","zoom":19,"extra_fields":{"post_excerpt":"This person will function as a heavy equipment mechanic and should maintain a willingness to do, learn, perform and improve&hellip;","post_content":"<p>This person will function as a heavy equipment mechanic and should maintain a willingness to do, learn, perform and improve any maintenance task. They will be working on a variety of heavy-duty earthmoving equipment.&nbsp;<\/p><p>This person should have experience with the following:<br>-Diagnostics and troubleshooting<br>-Welding<br>-3-5 years of mechanical experience<br>-Knowledge to maintain\/repair AC, hydraulic, electrical, compressed air, and powertrain systems<br>-Knowledge to maintain\/repair braking and steering systems<br>-Knowledge to maintain\/repair engine overheads and procedures<br>&nbsp;-Lifting and rigging<\/p>","post_title":"Heavy Equipment Mechanic","post_link":"https:\/\/turnerstaffing.com\/position\/heavy-equipment-mechanic-5\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"","%location_country%":"United States","%location_city%":"Eureka Area","%location_state_id%":"NV","%location_state_name%":"Nevada","%location_city_state%":"Eureka Area, NV","%education%":"","%department%":"","%description%":"<p>This person will function as a heavy equipment mechanic and should maintain a willingness to do, learn, perform and improve any maintenance task. They will be working on a variety of heavy-duty earthmoving equipment.&nbsp;<\/p><p>This person should have experience with the following:<br>-Diagnostics and troubleshooting<br>-Welding<br>-3-5 years of mechanical experience<br>-Knowledge to maintain\/repair AC, hydraulic, electrical, compressed air, and powertrain systems<br>-Knowledge to maintain\/repair braking and steering systems<br>-Knowledge to maintain\/repair engine overheads and procedures<br>&nbsp;-Lifting and rigging<\/p>","%category%":"","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/871f7d6ef660-heavy-equipment-mechanic","%breezy_id%":"871f7d6ef660","%breezy_friendly_id%":"871f7d6ef660-heavy-equipment-mechanic","%breezy_created_date%":"2024-07-17T19:32:50.703Z","%breezy_updated_date%":"2025-01-29T21:18:38.902Z","%_wpgmp_location_city%":"Eureka Area","%_wpgmp_location_state%":"NV","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Eureka Area, NV, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"39.5124858","%_wpgmp_metabox_longitude%":"-115.9607803","%rank_math_internal_links_processed%":"1"}},"id":1589,"infowindow_disable":false},{"source":"post","title":"Heavy Equipment Fuel Lube Technician","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Heavy Equipment Fuel Lube Technician\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Heavy Equipment Fuel &amp; Lube Technician Job Description Do you love mining? Do you think differently? Are you ready to&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/heavy-equipment-fuel-lube-technician-3\/\" name=\"Heavy Equipment Fuel Lube Technician\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Heavy Equipment Fuel &amp; Lube Technician Job Description Do you love mining? Do you think differently? Are you ready to&hellip;","address":"Kermit, TX, USA","location":{"lat":"31.8576265","city":"Kermit","state":"TX","country":"United States","lng":"-103.0926652","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/heavy-equipment-fuel-lube-technician-3\/","zoom":19,"extra_fields":{"post_excerpt":"Heavy Equipment Fuel &amp; Lube Technician Job Description Do you love mining? Do you think differently? Are you ready to&hellip;","post_content":"<p style=\"color:#000000\"><strong><u>Heavy Equipment Fuel &amp; Lube Technician Job Description<\/u><\/strong><\/p>\n<p style=\"color:#000000\"><span style=\"color:#333333\">Do you love mining? Do you think differently? Are you ready to define the future of this industry?<\/span><\/p>\n<p style=\"color:#000000\"><span style=\"color:#333333\">We\u2019ve been waiting for you! Turner Mining Group is committed to changing the way mining companies do business. We develop our people. We partner with our clients. We believe in win, win, win.<\/span><\/p>\n<p>We are looking for a dynamic and talented professional to fill a&nbsp;<strong>Fuel &amp; Lube Technician<\/strong>&nbsp;role at our fast-growing, forward thinking mining services company.<\/p>\n<p style=\"color:#000000\"><span style=\"color:#333333\">This person will function as a&nbsp;<\/span><strong>Fuel &amp; Lube Technician<\/strong><span style=\"color:#333333\">, willingness to do, learn, perform and improve any maintenance task. Tasks will be defined and evolve in all areas of mining operations to ensure preventative maintenance is practiced, repairs, equipment runs in the area of responsibility. This is an opportunity to work as part of the operations team in a safe, productive, and fun environment.<\/span><\/p>\n<p style=\"color:#000000\"><span style=\"color:#333333\"><\/span><strong><span style=\"color:#333333\">Essential Skills &amp; Knowledge<\/span><\/strong><\/p>\n<p style=\"color:#000000\"><span style=\"color:#333333\">\u2022 Follow a consistent and regular schedule to perform various types of maintenance on heavy equipment and various pieces of machinery&nbsp;<\/span><\/p>\n<p style=\"color:#000000\"><span style=\"color:#333333\">\u2022 Perform minor repairs on equipment using tools, machine tools and measuring instruments&nbsp;<\/span><span style=\"color:#333333\"><\/span><\/p>\n<p style=\"color:#000000\"><span style=\"color:#333333\">\u2022 Conduct oil changes, lubrication of equipment, tire replacements, hose repairs, battery replacements and assorted services&nbsp;<\/span><span style=\"color:#333333\"><\/span><\/p>\n<p style=\"color:#000000\"><span style=\"color:#333333\">\u2022 Operate and test equipment&nbsp;<\/span><span style=\"color:#333333\"><\/span><\/p>\n<p style=\"color:#000000\"><span style=\"color:#333333\">\u2022 Produce detailed service reports and repair logs&nbsp;<\/span><\/p>\n<p style=\"color:#000000\"><span style=\"color:#333333\">\u2022 Follow all established procedures and protocols&nbsp;<\/span><\/p>\n<p style=\"color:#000000\"><span style=\"color:#333333\">\u2022 Build positive relationships with internal and external teams<\/span><\/p>\n<p style=\"color:#000000\"><span style=\"color:#333333\">\u2022 Perform additional duties as assigned<\/span><\/p>\n<p style=\"color:#000000\"><strong><span style=\"color:#333333\">Benefits<\/span><\/strong><\/p>\n<p style=\"color:#000000\"><span style=\"color:#333333\">Turner Mining Group offers a competitive salary, an excellent work culture, career advancement opportunities. Our team offers a benefits program which includes Medical, Dental, Vision, Life, and a 401k with company match. We believe in a work life balance and established paid time off for major holidays.<\/span><\/p>\n<p style=\"color:#000000\"><span style=\"color:#333333\">At Turner Mining Group, we encourage and celebrate an inclusive environment for all employees and are proud to be an equal opportunity workplace and affirmative action employer.<\/span><\/p>","post_title":"Heavy Equipment Fuel Lube Technician","post_link":"https:\/\/turnerstaffing.com\/position\/heavy-equipment-fuel-lube-technician-3\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"","%location_country%":"United States","%location_city%":"Kermit","%location_state_id%":"TX","%location_state_name%":"Texas","%location_city_state%":"Kermit, TX","%education%":"","%department%":"","%description%":"<p style=\"color:#000000;\"><strong><u>Heavy Equipment Fuel &amp; Lube Technician Job Description<\/u><\/strong><\/p>\n<p style=\"color:#000000;\"><span style=\"color:#333333;\">Do you love mining? Do you think differently? Are you ready to define the future of this industry?<\/span><\/p>\n<p style=\"color:#000000;\"><span style=\"color:#333333;\">We\u2019ve been waiting for you! Turner Mining Group is committed to changing the way mining companies do business. We develop our people. We partner with our clients. We believe in win, win, win.<\/span><\/p>\n<p>We are looking for a dynamic and talented professional to fill a&nbsp;<strong>Fuel &amp; Lube Technician<\/strong>&nbsp;role at our fast-growing, forward thinking mining services company.<\/p>\n<p style=\"color:#000000;\"><span style=\"color:#333333;\">This person will function as a&nbsp;<\/span><strong>Fuel &amp; Lube Technician<\/strong><span style=\"color:#333333;\">, willingness to do, learn, perform and improve any maintenance task. Tasks will be defined and evolve in all areas of mining operations to ensure preventative maintenance is practiced, repairs, equipment runs in the area of responsibility. This is an opportunity to work as part of the operations team in a safe, productive, and fun environment.<\/span><\/p>\n<p style=\"color:#000000;\"><span style=\"color:#333333;\"><\/span><strong><span style=\"color:#333333;\">Essential Skills &amp; Knowledge<\/span><\/strong><\/p>\n<p style=\"color:#000000;\"><span style=\"color:#333333;\">\u2022 Follow a consistent and regular schedule to perform various types of maintenance on heavy equipment and various pieces of machinery&nbsp;<\/span><\/p>\n<p style=\"color:#000000;\"><span style=\"color:#333333;\">\u2022 Perform minor repairs on equipment using tools, machine tools and measuring instruments&nbsp;<\/span><span style=\"color:#333333;\"><\/span><\/p>\n<p style=\"color:#000000;\"><span style=\"color:#333333;\">\u2022 Conduct oil changes, lubrication of equipment, tire replacements, hose repairs, battery replacements and assorted services&nbsp;<\/span><span style=\"color:#333333;\"><\/span><\/p>\n<p style=\"color:#000000;\"><span style=\"color:#333333;\">\u2022 Operate and test equipment&nbsp;<\/span><span style=\"color:#333333;\"><\/span><\/p>\n<p style=\"color:#000000;\"><span style=\"color:#333333;\">\u2022 Produce detailed service reports and repair logs&nbsp;<\/span><\/p>\n<p style=\"color:#000000;\"><span style=\"color:#333333;\">\u2022 Follow all established procedures and protocols&nbsp;<\/span><\/p>\n<p style=\"color:#000000;\"><span style=\"color:#333333;\">\u2022 Build positive relationships with internal and external teams<\/span><\/p>\n<p style=\"color:#000000;\"><span style=\"color:#333333;\">\u2022 Perform additional duties as assigned<\/span><\/p>\n<p style=\"color:#000000;\"><strong><span style=\"color:#333333;\">Benefits<\/span><\/strong><\/p>\n<p style=\"color:#000000;\"><span style=\"color:#333333;\">Turner Mining Group offers a competitive salary, an excellent work culture, career advancement opportunities. Our team offers a benefits program which includes Medical, Dental, Vision, Life, and a 401k with company match. We believe in a work life balance and established paid time off for major holidays.<\/span><\/p>\n<p style=\"color:#000000;\"><span style=\"color:#333333;\">At Turner Mining Group, we encourage and celebrate an inclusive environment for all employees and are proud to be an equal opportunity workplace and affirmative action employer.<\/span><\/p>","%category%":"Operations","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/aadd4302e14b-heavy-equipment-fuel-lube-technician","%breezy_id%":"aadd4302e14b","%breezy_friendly_id%":"aadd4302e14b-heavy-equipment-fuel-lube-technician","%breezy_created_date%":"2022-09-23T19:46:37.705Z","%breezy_updated_date%":"2025-02-26T15:22:36.666Z","%_wpgmp_location_city%":"Kermit","%_wpgmp_location_state%":"TX","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Kermit, TX, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"31.8576265","%_wpgmp_metabox_longitude%":"-103.0926652","%rank_math_internal_links_processed%":"1"}},"id":1587,"infowindow_disable":false},{"source":"post","title":"Maintenance Mechanic","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Maintenance Mechanic\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Maintenance Mechanic&nbsp; Job Description: Repairs and maintains plant equipment as assigned, including electric and gas welding, hydraulics, rigging, pipe fitting,&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/maintenance-mechanic\/\" name=\"Maintenance Mechanic\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Maintenance Mechanic&nbsp; Job Description: Repairs and maintains plant equipment as assigned, including electric and gas welding, hydraulics, rigging, pipe fitting,&hellip;","address":"Gabbs, NV, USA","location":{"lat":"38.8690562","city":"Gabbs","state":"NV","country":"United States","lng":"-117.9228819","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/maintenance-mechanic\/","zoom":19,"extra_fields":{"post_excerpt":"Maintenance Mechanic&nbsp; Job Description: Repairs and maintains plant equipment as assigned, including electric and gas welding, hydraulics, rigging, pipe fitting,&hellip;","post_content":"<p>Maintenance Mechanic&nbsp;<\/p><p>Job Description:<\/p><p>Repairs and maintains plant equipment as assigned, including electric and gas welding, hydraulics, rigging, pipe fitting, <br>pumps, air compressors, vacuum pumps, bearings and seals, power transmissions, gear boxes, equipment settings and <br>alignment.<\/p><p>Job Requirements:<\/p><p>Must have a minimum set of hand tools as specified by the Company.  Previous experience must include a minimum of four <br>years as a millwright.<br>Job includes but is not limited to: repair of conveyor belts, bucket elevators, crushers, ball mills, screens, pumps, etc. <br>Experience in industrial construction and\/or repair may count. Must be able to read and understand blueprints and equipment <br>instructions. Must be able to weld with enough proficiency to pass a Company welding test in both electrical arc and <br>oxygen\/acetylene welding and understand the safe handling of welding equipment.  Must be able to determine what type of <br>rod to use on different types of steel and cast iron. Must be thoroughly familiar with all aspects of safety in the maintenance <br>field.  Must be capable of working with a minimum of supervision. Must be able to work all shifts. A written test will be <br>given as part of the company\u2019s evaluation of aptitude for the job. All work described above to be done in an efficient and <br>workman-like manner. This position is subject to duties as assigned.<br>This position is subject to shift work.<br>Additional :<br>Job requires a thorough knowledge of the load bearing capabilities of the equipment used as well as an understanding of <br>blueprints and technical instructions. Primary purpose of installing, maintaining, upgrading, and fabricating machinery and <br>equipment according to layout plans, blueprints, and other drawings in industrial establishment.<br>Typical duties include:<br>\uf0b7Read blueprints and schematic drawings to determine work procedures. Dismantle machinery or equipment, using hammers, <br>wrenches, crowbars, and other hand tools.<br>\uf0b7Moves machinery and equipment, using hoists, dollies, rollers, and trucks.<br>\uf0b7Assembles and installs equipment, such as shafting, conveyors, and tram rails, using hand tools and power tools.<br>\uf0b7Constructs foundation for machines, using hand tools and building materials, such as wood cement, and steel.<br>\uf0b7Align machines and equipment, using hoists, jacks, hand tools, squares, rules, micrometers, lasers, and plumb bobs.<br>\uf0b7Assembles machinery and bolts, welds, rivets, or otherwise fastens them to foundation or other structures, using hand tools <br>and power tools.<br>\uf0b7May operate engine lathe or milling machine to grind, file, and turn machine parts to dimensional specifications.<br>\uf0b7Required repair and lubricate machinery and equipment.<br>\uf0b7Selects cables, ropes, chains, pulleys, winches, blocks, and sheaves, according to weight and size of load to be moved.<br>\uf0b7Attaches load with grappling devices, such as loops, wires, ropes, and chains, to crane hook.<br>\uf0b7Sets up, braces, and rigs hoisting equipment, using hand tools and power wrenches.<br>\uf0b7May direct workers engaged in hoisting of machinery and equipment.<br>\uf0b7In addition, may perform all duties of General Laborer, Skilled Laborer and Carpenter and possibly electrician.<br>Should be able to:<br>\uf0b7Work within precise limits or standards of accuracy.<br>\uf0b7Follow instructions and read blueprints.<br>\uf0b7Look at flat drawings or pictures and visualize how they would look as solid objects.<br>\uf0b7Work at heights without fear.<br>\uf0b7Use logical step-by-step procedures at work.<br>\uf0b7Plan work and solve problems.<br>\uf0b7Make decisions based on measurable information.<br>\uf0b7Perform a variety of duties which may change often; and operate machinery.<br>Millwrights must be physically able to:<br>\uf0b7Coordinate eye-hand movements.<br>\uf0b7Use hands and fingers fully; reach for, manipulate, and feel objects; stoop, kneel, crouch, and\/or crawl;<br>\uf0b7Climb and maintain body balance on ladders, scaffolding, or high structures; and see and hear well (either naturally or with <br>correction);<br>\uf0b7Lift and carry objects weighing up to 100 pounds.<br>\uf0b7Stoop, lay, bend or squat for long periods of time.<\/p>","post_title":"Maintenance Mechanic","post_link":"https:\/\/turnerstaffing.com\/position\/maintenance-mechanic\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"","%location_country%":"United States","%location_city%":"Gabbs","%location_state_id%":"NV","%location_state_name%":"Nevada","%location_city_state%":"Gabbs, NV","%education%":"","%department%":"","%description%":"<p>Maintenance Mechanic&nbsp;<\/p><p>Job Description:<\/p><p>Repairs and maintains plant equipment as assigned, including electric and gas welding, hydraulics, rigging, pipe fitting, <br>pumps, air compressors, vacuum pumps, bearings and seals, power transmissions, gear boxes, equipment settings and <br>alignment.<\/p><p>Job Requirements:<\/p><p>Must have a minimum set of hand tools as specified by the Company.  Previous experience must include a minimum of four <br>years as a millwright.<br>Job includes but is not limited to: repair of conveyor belts, bucket elevators, crushers, ball mills, screens, pumps, etc. <br>Experience in industrial construction and\/or repair may count. Must be able to read and understand blueprints and equipment <br>instructions. Must be able to weld with enough proficiency to pass a Company welding test in both electrical arc and <br>oxygen\/acetylene welding and understand the safe handling of welding equipment.  Must be able to determine what type of <br>rod to use on different types of steel and cast iron. Must be thoroughly familiar with all aspects of safety in the maintenance <br>field.  Must be capable of working with a minimum of supervision. Must be able to work all shifts. A written test will be <br>given as part of the company\u2019s evaluation of aptitude for the job. All work described above to be done in an efficient and <br>workman-like manner. This position is subject to duties as assigned.<br>This position is subject to shift work.<br>Additional :<br>Job requires a thorough knowledge of the load bearing capabilities of the equipment used as well as an understanding of <br>blueprints and technical instructions. Primary purpose of installing, maintaining, upgrading, and fabricating machinery and <br>equipment according to layout plans, blueprints, and other drawings in industrial establishment.<br>Typical duties include:<br>\uf0b7Read blueprints and schematic drawings to determine work procedures. Dismantle machinery or equipment, using hammers, <br>wrenches, crowbars, and other hand tools.<br>\uf0b7Moves machinery and equipment, using hoists, dollies, rollers, and trucks.<br>\uf0b7Assembles and installs equipment, such as shafting, conveyors, and tram rails, using hand tools and power tools.<br>\uf0b7Constructs foundation for machines, using hand tools and building materials, such as wood cement, and steel.<br>\uf0b7Align machines and equipment, using hoists, jacks, hand tools, squares, rules, micrometers, lasers, and plumb bobs.<br>\uf0b7Assembles machinery and bolts, welds, rivets, or otherwise fastens them to foundation or other structures, using hand tools <br>and power tools.<br>\uf0b7May operate engine lathe or milling machine to grind, file, and turn machine parts to dimensional specifications.<br>\uf0b7Required repair and lubricate machinery and equipment.<br>\uf0b7Selects cables, ropes, chains, pulleys, winches, blocks, and sheaves, according to weight and size of load to be moved.<br>\uf0b7Attaches load with grappling devices, such as loops, wires, ropes, and chains, to crane hook.<br>\uf0b7Sets up, braces, and rigs hoisting equipment, using hand tools and power wrenches.<br>\uf0b7May direct workers engaged in hoisting of machinery and equipment.<br>\uf0b7In addition, may perform all duties of General Laborer, Skilled Laborer and Carpenter and possibly electrician.<br>Should be able to:<br>\uf0b7Work within precise limits or standards of accuracy.<br>\uf0b7Follow instructions and read blueprints.<br>\uf0b7Look at flat drawings or pictures and visualize how they would look as solid objects.<br>\uf0b7Work at heights without fear.<br>\uf0b7Use logical step-by-step procedures at work.<br>\uf0b7Plan work and solve problems.<br>\uf0b7Make decisions based on measurable information.<br>\uf0b7Perform a variety of duties which may change often; and operate machinery.<br>Millwrights must be physically able to:<br>\uf0b7Coordinate eye-hand movements.<br>\uf0b7Use hands and fingers fully; reach for, manipulate, and feel objects; stoop, kneel, crouch, and\/or crawl;<br>\uf0b7Climb and maintain body balance on ladders, scaffolding, or high structures; and see and hear well (either naturally or with <br>correction);<br>\uf0b7Lift and carry objects weighing up to 100 pounds.<br>\uf0b7Stoop, lay, bend or squat for long periods of time.<\/p>","%category%":"","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/92135d17b2ce-maintenance-mechanic","%breezy_id%":"92135d17b2ce","%breezy_friendly_id%":"92135d17b2ce-maintenance-mechanic","%breezy_created_date%":"2024-07-11T00:58:06.228Z","%breezy_updated_date%":"2025-02-11T15:55:19.084Z","%_wpgmp_location_city%":"Gabbs","%_wpgmp_location_state%":"NV","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Gabbs, NV, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"38.8690562","%_wpgmp_metabox_longitude%":"-117.9228819","%rank_math_internal_links_processed%":"1"}},"id":1569,"infowindow_disable":false},{"source":"post","title":"Heavy Equipment Mechanic &#8211; Mining","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Heavy Equipment Mechanic &#8211; Mining\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Bald Mountain is an open-pit mine with a large estimated mineral resource base located in Nevada.&nbsp; Job Description The mechanic&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/haul-and-aux-mechanic\/\" name=\"Heavy Equipment Mechanic &#8211; Mining\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Bald Mountain is an open-pit mine with a large estimated mineral resource base located in Nevada.&nbsp; Job Description The mechanic&hellip;","address":"Bald Mountain, NV, USA","location":{"lat":"38.5343602","city":"Bald Mountain","state":"NV","country":"United States","lng":"-119.115983","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/haul-and-aux-mechanic\/","zoom":19,"extra_fields":{"post_excerpt":"Bald Mountain is an open-pit mine with a large estimated mineral resource base located in Nevada.&nbsp; Job Description The mechanic&hellip;","post_content":"<p>Bald Mountain is an open-pit mine with a large estimated mineral resource base located in Nevada.&nbsp;<\/p>\n<h2>Job Description<\/h2>\n<p>The mechanic is responsible for the general mechanical maintenance of haul trucks, graders\/dozers, water trucks, while continuously aligning daily functions.<\/p>\n<h2>Job Responsibilities<\/h2>\n<ul><li>Obey all MSHA and KGBM safety rules<\/li><li>Displays the ability to accurately diagnose and troubleshoot mechanical problems on heavy equipment<\/li><li>Make repairs in a timely fashion in order to get the job done and reduce downtime<\/li><li>Order parts accurately, and complete all necessary paperwork involved<\/li><li>Work with Maintenance Personnel to repair mining equipment with the least amount of machinery downtime possible to effectively repair the equipment<\/li><li>Accurately troubleshoot all mechanical problems on machinery and parts to be repaired<\/li><li>Performs all work assigned to him in a safe, well managed manner and assures that the area is safe for mechanics and other employees to work<\/li><li>Returns well-documented, and accurately completed work orders in a timely manner<\/li><li>Keeps in active communication with the Maintenance Supervisor and other crews to coordinate work and provide updates on work in progress<\/li><li>Compliance with all company policies and procedures including, but not limited to safety, environmental, confidentiality and code of conduct<\/li><li>Meets or exceeds established performance expectations set by management<\/li><li>Consistently exercises discretion and judgment in job performance<\/li><li>Works without risk or harm to self or others<\/li><li>Punctuality&nbsp;and regular attendance required<\/li><li>Helps develop other department personnel to perform duties listed above<\/li><li>Performs other related functions as assigned by supervisor<\/li><\/ul>\n<h2>Qualifications and Skill Requirements<\/h2>\n<ul><li>7 years diesel repair experience is required<\/li><li>Diesel Technician's Degree preferred<\/li><li>Should have strong mechanical aptitude, and knowledge of all machinery under his\/her maintenance<\/li><li>Strong knowledge in braking systems, steering systems, suspension systems, payload systems, compressed air systems, engine tune-up requirements, electronic engine controls, drive trains and electric drive haul truck braking\/dynamic systems<\/li><li>Able to read and understand hydrological and electrical schematics<\/li><li>Must have a working knowledge of all tools and equipment necessary to work in the Maintenance Department<\/li><li>Must be proficient with CMMS system, JDE plus<\/li><li>Must be able to solve problems effectively in a variety of areas, including mechanical issues<\/li><li>Ability to work in a team environment with minimal supervision<\/li><li>Ability to perform basic welding and cutting<\/li><li>Ablitly to operate various equipment including forklifts and service trucks<\/li><li>Ability to work in all weather conditions<\/li><li>Possesses good communication and interpersonal skills<\/li><li>General understanding of mining operations, as well as limited understanding of milling and maintenance operations<\/li><li>Working knowledge and skill with P.C. utilizing word processing, spreadsheet, database, and presentation software<\/li><li>Strong verbal, written, analytical and persuasive skills and the ability to interact effectively with all levels of employees and management&nbsp;<\/li><li>Ability to work independently and as a member of the management team<\/li><li>Demonstrates strong administrative, organizational and technical writing skills<\/li><li>Must be 18 years old and presently authorized to work in the United States on a full time basis<\/li><\/ul>","post_title":"Heavy Equipment Mechanic &#8211; Mining","post_link":"https:\/\/turnerstaffing.com\/position\/haul-and-aux-mechanic\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"","%location_country%":"United States","%location_city%":"Bald Mountain","%location_state_id%":"NV","%location_state_name%":"Nevada","%location_city_state%":"Bald Mountain, NV","%education%":"","%department%":"","%description%":"<p>Bald Mountain is an open-pit mine with a large estimated mineral resource base located in Nevada.&nbsp;<\/p>\n<h2>Job Description<\/h2>\n<p>The mechanic is responsible for the general mechanical maintenance of haul trucks, graders\/dozers, water trucks, while continuously aligning daily functions.<\/p>\n<h2>Job Responsibilities<\/h2>\n<ul><li>Obey all MSHA and KGBM safety rules<\/li><li>Displays the ability to accurately diagnose and troubleshoot mechanical problems on heavy equipment<\/li><li>Make repairs in a timely fashion in order to get the job done and reduce downtime<\/li><li>Order parts accurately, and complete all necessary paperwork involved<\/li><li>Work with Maintenance Personnel to repair mining equipment with the least amount of machinery downtime possible to effectively repair the equipment<\/li><li>Accurately troubleshoot all mechanical problems on machinery and parts to be repaired<\/li><li>Performs all work assigned to him in a safe, well managed manner and assures that the area is safe for mechanics and other employees to work<\/li><li>Returns well-documented, and accurately completed work orders in a timely manner<\/li><li>Keeps in active communication with the Maintenance Supervisor and other crews to coordinate work and provide updates on work in progress<\/li><li>Compliance with all company policies and procedures including, but not limited to safety, environmental, confidentiality and code of conduct<\/li><li>Meets or exceeds established performance expectations set by management<\/li><li>Consistently exercises discretion and judgment in job performance<\/li><li>Works without risk or harm to self or others<\/li><li>Punctuality&nbsp;and regular attendance required<\/li><li>Helps develop other department personnel to perform duties listed above<\/li><li>Performs other related functions as assigned by supervisor<\/li><\/ul>\n<h2>Qualifications and Skill Requirements<\/h2>\n<ul><li>7 years diesel repair experience is required<\/li><li>Diesel Technician's Degree preferred<\/li><li>Should have strong mechanical aptitude, and knowledge of all machinery under his\/her maintenance<\/li><li>Strong knowledge in braking systems, steering systems, suspension systems, payload systems, compressed air systems, engine tune-up requirements, electronic engine controls, drive trains and electric drive haul truck braking\/dynamic systems<\/li><li>Able to read and understand hydrological and electrical schematics<\/li><li>Must have a working knowledge of all tools and equipment necessary to work in the Maintenance Department<\/li><li>Must be proficient with CMMS system, JDE plus<\/li><li>Must be able to solve problems effectively in a variety of areas, including mechanical issues<\/li><li>Ability to work in a team environment with minimal supervision<\/li><li>Ability to perform basic welding and cutting<\/li><li>Ablitly to operate various equipment including forklifts and service trucks<\/li><li>Ability to work in all weather conditions<\/li><li>Possesses good communication and interpersonal skills<\/li><li>General understanding of mining operations, as well as limited understanding of milling and maintenance operations<\/li><li>Working knowledge and skill with P.C. utilizing word processing, spreadsheet, database, and presentation software<\/li><li>Strong verbal, written, analytical and persuasive skills and the ability to interact effectively with all levels of employees and management&nbsp;<\/li><li>Ability to work independently and as a member of the management team<\/li><li>Demonstrates strong administrative, organizational and technical writing skills<\/li><li>Must be 18 years old and presently authorized to work in the United States on a full time basis<\/li><\/ul>","%category%":"","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/1fa6c1447609-heavy-equipment-mechanic-mining","%breezy_id%":"1fa6c1447609","%breezy_friendly_id%":"1fa6c1447609-heavy-equipment-mechanic-mining","%breezy_created_date%":"2024-05-14T14:20:25.158Z","%breezy_updated_date%":"2025-01-29T21:18:32.579Z","%_wpgmp_location_city%":"Bald Mountain","%_wpgmp_location_state%":"NV","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Bald Mountain, NV, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"38.5343602","%_wpgmp_metabox_longitude%":"-119.115983","%rank_math_internal_links_processed%":"1","%rank_math_analytic_object_id%":"12"}},"id":1388,"infowindow_disable":false},{"source":"post","title":"Industrial Electrician","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Industrial Electrician\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Round Mountain is an open-pit mine located in Nevada, one of the best mining jurisdictions in the world. The mine&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/industrial-electrician-7\/\" name=\"Industrial Electrician\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Round Mountain is an open-pit mine located in Nevada, one of the best mining jurisdictions in the world. The mine&hellip;","address":"Round Mountain, NV, USA","location":{"lat":"38.7110428","city":"Round Mountain","state":"NV","country":"United States","lng":"-117.0675843","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/industrial-electrician-7\/","zoom":19,"extra_fields":{"post_excerpt":"Round Mountain is an open-pit mine located in Nevada, one of the best mining jurisdictions in the world. The mine&hellip;","post_content":"<p>Round Mountain is an open-pit mine located in Nevada, one of the best mining jurisdictions in the world. The mine uses conventional open-pit mining methods and processes ore by mill and heap leach.&nbsp;<\/p>\n<p>The Round Mountain mine is an important contributor to the Nye County economy and, working with local stakeholders, has helped achieve significant improvements in healthcare and education in the area.<\/p>\n<h2>Job Description<\/h2>\n<p>Under the general supervision of the Electrical Maintenance Supervisor, the incumbent oversees every aspect of the electrical systems on the mine site, and is responsible for their repair and maintenance.<\/p>\n<h2>Job Responsibilities<\/h2>\n<ul><li>Maintain, troubleshoot, and repair AC\/DC drive systems, AC\/DC motors, electrical shovel, electrical power distribution, protection systems, metering, PLC\u2019s, and lighting systems.<\/li><li>Moving, hauling, and lifting equipment as required by the repair or maintenance being performed.<\/li><li>Learn to order parts, and specify certain parts when ordering, and complete appropriate paperwork.<\/li><li>Train for higher levels of responsibility.<\/li><li>Responsible to manage the RMGC Environmental Health and Safety Management system in his\/her areas of responsibility.<\/li><li>Compliance with all company policies and procedures including, but not limited to safety, environmental, confidentiality and code of conduct.<\/li><li>Meets or exceeds established performance expectations set by management.<\/li><li>Consistently exercises discretion and judgment in job performance.<\/li><li>Works without risk or harm to self and others.<\/li><li>Punctuality and regular attendance required.<\/li><li>Helps develop other department personnel to perform duties listed above.<\/li><li>Performs other related functions as assigned by supervisor.<\/li><\/ul>\n<h2>Education and Experience<\/h2>\n<ul><li>Knowledge of electronics and electrical power.<\/li><li>Be constantly aware of personal safety.&nbsp;&nbsp; The incumbent must understand what actions can lead to dangerous reactions and know the proper steps to take in order to perform each job safely.<\/li><li>Capable of lifting and hauling equipment necessary to complete each job.<\/li><li>Be able to accurately complete appropriate paperwork associated with ordering parts.&nbsp;<\/li><li>Electrical background required; either a college or technical degree or Journeyman.<\/li><li>Work will be performed both indoors and outdoors in a general industrial environment.&nbsp;&nbsp; The incumbent may be asked to work straight days or shiftwork with overtime as needed.&nbsp;&nbsp; Appropriate PPE must be worn at all times.<\/li><li>Possesses good communication and interpersonal skills.<\/li><li>General understanding of mining operations, as well as limited understanding of milling and maintenance operations.<\/li><li>Working knowledge and skill with P.C. utilizing word processing, spreadsheet, database, and presentation software.<\/li><li>Strong verbal, written, analytical and persuasive skills and the ability to interact effectively with all levels of employees and management.<\/li><li>Ability to work independently and also as a member of the management team.<\/li><li>Demonstrates strong administrative, organizational and technical writing skills.<\/li><li>Must be 18 years old and presently authorized to work in the United States on a full time basis.<\/li><li>Requires valid driver\u2019s license.<\/li><\/ul>","post_title":"Industrial Electrician","post_link":"https:\/\/turnerstaffing.com\/position\/industrial-electrician-7\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"","%location_country%":"United States","%location_city%":"Round Mountain","%location_state_id%":"NV","%location_state_name%":"Nevada","%location_city_state%":"Round Mountain, NV","%education%":"","%department%":"","%description%":"<p>Round Mountain is an open-pit mine located in Nevada, one of the best mining jurisdictions in the world. The mine uses conventional open-pit mining methods and processes ore by mill and heap leach.&nbsp;<\/p>\n<p>The Round Mountain mine is an important contributor to the Nye County economy and, working with local stakeholders, has helped achieve significant improvements in healthcare and education in the area.<\/p>\n<h2>Job Description<\/h2>\n<p>Under the general supervision of the Electrical Maintenance Supervisor, the incumbent oversees every aspect of the electrical systems on the mine site, and is responsible for their repair and maintenance.<\/p>\n<h2>Job Responsibilities<\/h2>\n<ul><li>Maintain, troubleshoot, and repair AC\/DC drive systems, AC\/DC motors, electrical shovel, electrical power distribution, protection systems, metering, PLC\u2019s, and lighting systems.<\/li><li>Moving, hauling, and lifting equipment as required by the repair or maintenance being performed.<\/li><li>Learn to order parts, and specify certain parts when ordering, and complete appropriate paperwork.<\/li><li>Train for higher levels of responsibility.<\/li><li>Responsible to manage the RMGC Environmental Health and Safety Management system in his\/her areas of responsibility.<\/li><li>Compliance with all company policies and procedures including, but not limited to safety, environmental, confidentiality and code of conduct.<\/li><li>Meets or exceeds established performance expectations set by management.<\/li><li>Consistently exercises discretion and judgment in job performance.<\/li><li>Works without risk or harm to self and others.<\/li><li>Punctuality and regular attendance required.<\/li><li>Helps develop other department personnel to perform duties listed above.<\/li><li>Performs other related functions as assigned by supervisor.<\/li><\/ul>\n<h2>Education and Experience<\/h2>\n<ul><li>Knowledge of electronics and electrical power.<\/li><li>Be constantly aware of personal safety.&nbsp;&nbsp; The incumbent must understand what actions can lead to dangerous reactions and know the proper steps to take in order to perform each job safely.<\/li><li>Capable of lifting and hauling equipment necessary to complete each job.<\/li><li>Be able to accurately complete appropriate paperwork associated with ordering parts.&nbsp;<\/li><li>Electrical background required; either a college or technical degree or Journeyman.<\/li><li>Work will be performed both indoors and outdoors in a general industrial environment.&nbsp;&nbsp; The incumbent may be asked to work straight days or shiftwork with overtime as needed.&nbsp;&nbsp; Appropriate PPE must be worn at all times.<\/li><li>Possesses good communication and interpersonal skills.<\/li><li>General understanding of mining operations, as well as limited understanding of milling and maintenance operations.<\/li><li>Working knowledge and skill with P.C. utilizing word processing, spreadsheet, database, and presentation software.<\/li><li>Strong verbal, written, analytical and persuasive skills and the ability to interact effectively with all levels of employees and management.<\/li><li>Ability to work independently and also as a member of the management team.<\/li><li>Demonstrates strong administrative, organizational and technical writing skills.<\/li><li>Must be 18 years old and presently authorized to work in the United States on a full time basis.<\/li><li>Requires valid driver\u2019s license.<\/li><\/ul>","%category%":"","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/2321c15d849f-industrial-electrician","%breezy_id%":"2321c15d849f","%breezy_friendly_id%":"2321c15d849f-industrial-electrician","%breezy_created_date%":"2024-05-14T14:15:31.648Z","%breezy_updated_date%":"2025-02-25T13:50:41.158Z","%_wpgmp_location_city%":"Round Mountain","%_wpgmp_location_state%":"NV","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Round Mountain, NV, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"38.7110428","%_wpgmp_metabox_longitude%":"-117.0675843","%rank_math_internal_links_processed%":"1","%rank_math_analytic_object_id%":"14"}},"id":1386,"infowindow_disable":false},{"source":"post","title":"Light Vehicle Mechanic","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Light Vehicle Mechanic\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Job Title: Light Vehicle Mechanic Location: Elko, NV Job Description: As a Light Vehicle Mechanic, you will be responsible for&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/light-vehicle-mechanic\/\" name=\"Light Vehicle Mechanic\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Job Title: Light Vehicle Mechanic Location: Elko, NV Job Description: As a Light Vehicle Mechanic, you will be responsible for&hellip;","address":"Elko, NV, USA","location":{"lat":"40.8436459","city":"Elko","state":"NV","country":"United States","lng":"-115.7526187","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/light-vehicle-mechanic\/","zoom":19,"extra_fields":{"post_excerpt":"Job Title: Light Vehicle Mechanic Location: Elko, NV Job Description: As a Light Vehicle Mechanic, you will be responsible for&hellip;","post_content":"<p><strong><br>Job Title: Light Vehicle Mechanic<\/strong><br><\/p>\n\n<p><strong>Location: Elko, NV<\/strong><br><\/p>\n\n<p><strong>Job Description:<\/strong><\/p>\n<p>As a Light Vehicle Mechanic, you will be responsible for maintaining, diagnosing, and repairing light vehicles used in mining operations. Your expertise will ensure the reliability and safety of the company's fleet, contributing to the overall efficiency of mining activities.<\/p>\n<p><strong>Key Responsibilities:<\/strong><\/p>\n<ol><li><strong>Vehicle Maintenance:<\/strong> Perform routine maintenance tasks, including oil changes, filter replacements, tire rotations, and fluid checks, to keep light vehicles in optimal condition.<\/li><li><strong>Diagnosis and Repair:<\/strong> Troubleshoot and diagnose mechanical, electrical, and hydraulic issues in light vehicles, such as trucks, vans, and SUVs. Conduct repairs and replacements of faulty components to restore functionality.<\/li><li><strong>Inspections and Testing:<\/strong> Conduct thorough inspections of vehicles to identify any potential problems or safety concerns. Perform diagnostic tests and quality checks to ensure vehicles meet performance and safety standards.<\/li><li><strong>Parts and Inventory Management:<\/strong> Maintain accurate records of parts inventory and requisition supplies as needed. Coordinate with suppliers to procure replacement parts and ensure timely repairs.<\/li><li><strong>Safety Compliance:<\/strong> Adhere to all safety protocols and procedures to create a safe working environment. Ensure that vehicles are maintained in compliance with regulatory requirements and industry standards.<\/li><li><strong>Documentation:<\/strong> Complete detailed service reports, maintenance logs, and repair records to document work performed and track vehicle history. Maintain organized records for compliance and reference purposes.<\/li><li><strong>Team Collaboration:<\/strong> Work collaboratively with other members of the maintenance team and mining operations staff to coordinate vehicle maintenance activities and support overall operational goals.<\/li><\/ol>\n<p><strong>Qualifications:<\/strong><\/p>\n<ul><li>Proven experience as a light vehicle mechanic, preferably in a mining or heavy equipment environment.<\/li><li>Proficiency in diagnosing and repairing mechanical, electrical, and hydraulic systems in light vehicles.<\/li><li>Strong knowledge of automotive systems, components, and diagnostic tools.<\/li><li>Familiarity with safety regulations and best practices in vehicle maintenance.<\/li><li>Excellent problem-solving skills and attention to detail.<\/li><li>Ability to work independently and as part of a team in a fast-paced environment.<\/li><li>Valid driver's license and clean driving record.<\/li><li>Certification from a recognized automotive training program or equivalent experience is preferred.<\/li><\/ul>\n<p><strong>Benefits:<\/strong><\/p>\n<ul><li>Competitive salary commensurate with experience.<\/li><li>Comprehensive benefits package, including health insurance, retirement plans, and paid time off.<\/li><li>Opportunities for career advancement and professional development within the mining industry.<\/li><li>Supportive work environment with a focus on safety and teamwork.<\/li><\/ul>\n<p>Join our team and play a vital role in maintaining the reliability and efficiency of our light vehicle fleet. Apply now to become a Light Vehicle Mechanic with Turner Staffing Group and our partner mining company!<\/p>","post_title":"Light Vehicle Mechanic","post_link":"https:\/\/turnerstaffing.com\/position\/light-vehicle-mechanic\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Associate","%location_country%":"United States","%location_city%":"Elko","%location_state_id%":"NV","%location_state_name%":"Nevada","%location_city_state%":"Elko, NV","%education%":"Unspecified","%department%":"Equipment","%description%":"<p><strong><br>Job Title: Light Vehicle Mechanic<\/strong><br><\/p>\n\n<p><strong>Location: Elko, NV<\/strong><br><\/p>\n\n<p><strong>Job Description:<\/strong><\/p>\n<p>As a Light Vehicle Mechanic, you will be responsible for maintaining, diagnosing, and repairing light vehicles used in mining operations. Your expertise will ensure the reliability and safety of the company's fleet, contributing to the overall efficiency of mining activities.<\/p>\n<p><strong>Key Responsibilities:<\/strong><\/p>\n<ol><li><strong>Vehicle Maintenance:<\/strong> Perform routine maintenance tasks, including oil changes, filter replacements, tire rotations, and fluid checks, to keep light vehicles in optimal condition.<\/li><li><strong>Diagnosis and Repair:<\/strong> Troubleshoot and diagnose mechanical, electrical, and hydraulic issues in light vehicles, such as trucks, vans, and SUVs. Conduct repairs and replacements of faulty components to restore functionality.<\/li><li><strong>Inspections and Testing:<\/strong> Conduct thorough inspections of vehicles to identify any potential problems or safety concerns. Perform diagnostic tests and quality checks to ensure vehicles meet performance and safety standards.<\/li><li><strong>Parts and Inventory Management:<\/strong> Maintain accurate records of parts inventory and requisition supplies as needed. Coordinate with suppliers to procure replacement parts and ensure timely repairs.<\/li><li><strong>Safety Compliance:<\/strong> Adhere to all safety protocols and procedures to create a safe working environment. Ensure that vehicles are maintained in compliance with regulatory requirements and industry standards.<\/li><li><strong>Documentation:<\/strong> Complete detailed service reports, maintenance logs, and repair records to document work performed and track vehicle history. Maintain organized records for compliance and reference purposes.<\/li><li><strong>Team Collaboration:<\/strong> Work collaboratively with other members of the maintenance team and mining operations staff to coordinate vehicle maintenance activities and support overall operational goals.<\/li><\/ol>\n<p><strong>Qualifications:<\/strong><\/p>\n<ul><li>Proven experience as a light vehicle mechanic, preferably in a mining or heavy equipment environment.<\/li><li>Proficiency in diagnosing and repairing mechanical, electrical, and hydraulic systems in light vehicles.<\/li><li>Strong knowledge of automotive systems, components, and diagnostic tools.<\/li><li>Familiarity with safety regulations and best practices in vehicle maintenance.<\/li><li>Excellent problem-solving skills and attention to detail.<\/li><li>Ability to work independently and as part of a team in a fast-paced environment.<\/li><li>Valid driver's license and clean driving record.<\/li><li>Certification from a recognized automotive training program or equivalent experience is preferred.<\/li><\/ul>\n<p><strong>Benefits:<\/strong><\/p>\n<ul><li>Competitive salary commensurate with experience.<\/li><li>Comprehensive benefits package, including health insurance, retirement plans, and paid time off.<\/li><li>Opportunities for career advancement and professional development within the mining industry.<\/li><li>Supportive work environment with a focus on safety and teamwork.<\/li><\/ul>\n<p>Join our team and play a vital role in maintaining the reliability and efficiency of our light vehicle fleet. Apply now to become a Light Vehicle Mechanic with Turner Staffing Group and our partner mining company!<\/p>","%category%":"Operations","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/8a4f13b949cf-light-vehicle-mechanic","%breezy_id%":"8a4f13b949cf","%breezy_friendly_id%":"8a4f13b949cf-light-vehicle-mechanic","%breezy_created_date%":"2024-04-09T15:05:16.423Z","%breezy_updated_date%":"2025-02-18T15:09:46.451Z","%_wpgmp_location_city%":"Elko","%_wpgmp_location_state%":"NV","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Elko, NV, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"40.8436459","%_wpgmp_metabox_longitude%":"-115.7526187","%rank_math_internal_links_processed%":"1","%rank_math_analytic_object_id%":"47"}},"id":1326,"infowindow_disable":false},{"source":"post","title":"High Voltage Electrician","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    High Voltage Electrician\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Job Title: High Voltage ElectricianCompany:&nbsp;Turner Staffing GroupLocation: Nevada, USAEmployment Type: Full-time About Us:Turner Staffing Group is partnered with a leading&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/high-voltage-electrician\/\" name=\"High Voltage Electrician\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Job Title: High Voltage ElectricianCompany:&nbsp;Turner Staffing GroupLocation: Nevada, USAEmployment Type: Full-time About Us:Turner Staffing Group is partnered with a leading&hellip;","address":"Elko, NV, USA","location":{"lat":"40.8436459","city":"Elko","state":"NV","country":"United States","lng":"-115.7526187","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/high-voltage-electrician\/","zoom":19,"extra_fields":{"post_excerpt":"Job Title: High Voltage ElectricianCompany:&nbsp;Turner Staffing GroupLocation: Nevada, USAEmployment Type: Full-time About Us:Turner Staffing Group is partnered with a leading&hellip;","post_content":"<p><strong>Job Title:<\/strong> High Voltage Electrician<br><strong>Company:<\/strong>&nbsp;Turner Staffing Group<br><strong>Location:<\/strong> Nevada, USA<br><strong>Employment Type:<\/strong> Full-time<\/p>\n<p><strong>About Us:<\/strong><br>Turner Staffing Group is partnered with a leading player in the gold mining industry, operating in Nevada with a commitment to excellence in safety, sustainability, and productivity. Partnered with Turner Staffing Group, we are currently seeking a skilled High Voltage Electrician to join our team.<\/p>\n<p><strong>Job Description:<\/strong><br>As a High Voltage Electrician, you will be responsible for the maintenance, repair, and installation of high voltage electrical systems and equipment within our mining operations. This role will involve working with a team of professionals to ensure the safe and efficient operation of electrical infrastructure critical to our mining processes.<\/p>\n<p><strong>Key Responsibilities:<\/strong><\/p>\n<ul><li>Perform routine inspections, troubleshooting, and maintenance of high voltage electrical systems, including transformers, switchgear, and distribution lines.<\/li><li>Conduct repairs and replacements of faulty components to minimize downtime and ensure continuous operation of equipment.<\/li><li>Collaborate with engineering and maintenance teams to plan and execute electrical projects, upgrades, and expansions.<\/li><li>Adhere to safety protocols and regulatory standards to maintain a safe working environment for yourself and your team.<\/li><li>Document work activities, including inspections, repairs, and maintenance tasks, to maintain accurate records and facilitate effective communication.<\/li><\/ul>\n<p><strong>Requirements:<\/strong><\/p>\n<ul><li>High school diploma or equivalent; completion of a recognized electrical apprenticeship program preferred.<\/li><li>Journeyman Electrician license or equivalent certification required.<\/li><li>Minimum of 3 years of experience working with high voltage electrical systems, preferably in an industrial or mining environment.<\/li><li>Strong knowledge of electrical principles, codes, and regulations, with a focus on high voltage systems (4160V and above).<\/li><li>Ability to interpret electrical schematics, diagrams, and technical documentation.<\/li><li>Excellent problem-solving skills and attention to detail.<\/li><li>Effective communication and teamwork abilities.<\/li><li>Willingness to work in a dynamic and physically demanding environment, including outdoor and underground settings as required.<\/li><\/ul>\n<p><strong>Benefits:<\/strong><\/p>\n<ul><li>Competitive salary commensurate with experience.<\/li><li>Comprehensive benefits package, including medical, dental, vision, and retirement plans.<\/li><li>Opportunities for career growth and advancement within a leading mining organization.<\/li><li>Training and development programs to enhance your skills and knowledge.<\/li><li>A supportive work environment with a focus on safety and collaboration.<\/li><\/ul>\n<p><strong>How to Apply:<\/strong><br>If you are a qualified High Voltage Electrician looking for an exciting opportunity to contribute to the success of a dynamic mining operation, please submit your resume and cover letter through the Turner Staffing Group website!<\/p>\n<p>Turner Staffing Group is an equal opportunity employers committed to diversity and inclusion in the workplace.<\/p>","post_title":"High Voltage Electrician","post_link":"https:\/\/turnerstaffing.com\/position\/high-voltage-electrician\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Associate","%location_country%":"United States","%location_city%":"Elko","%location_state_id%":"NV","%location_state_name%":"Nevada","%location_city_state%":"Elko, NV","%education%":"High School or equivalent","%department%":"Operations","%description%":"<p><strong>Job Title:<\/strong> High Voltage Electrician<br><strong>Company:<\/strong>&nbsp;Turner Staffing Group<br><strong>Location:<\/strong> Nevada, USA<br><strong>Employment Type:<\/strong> Full-time<\/p>\n<p><strong>About Us:<\/strong><br>Turner Staffing Group is partnered with a leading player in the gold mining industry, operating in Nevada with a commitment to excellence in safety, sustainability, and productivity. Partnered with Turner Staffing Group, we are currently seeking a skilled High Voltage Electrician to join our team.<\/p>\n<p><strong>Job Description:<\/strong><br>As a High Voltage Electrician, you will be responsible for the maintenance, repair, and installation of high voltage electrical systems and equipment within our mining operations. This role will involve working with a team of professionals to ensure the safe and efficient operation of electrical infrastructure critical to our mining processes.<\/p>\n<p><strong>Key Responsibilities:<\/strong><\/p>\n<ul><li>Perform routine inspections, troubleshooting, and maintenance of high voltage electrical systems, including transformers, switchgear, and distribution lines.<\/li><li>Conduct repairs and replacements of faulty components to minimize downtime and ensure continuous operation of equipment.<\/li><li>Collaborate with engineering and maintenance teams to plan and execute electrical projects, upgrades, and expansions.<\/li><li>Adhere to safety protocols and regulatory standards to maintain a safe working environment for yourself and your team.<\/li><li>Document work activities, including inspections, repairs, and maintenance tasks, to maintain accurate records and facilitate effective communication.<\/li><\/ul>\n<p><strong>Requirements:<\/strong><\/p>\n<ul><li>High school diploma or equivalent; completion of a recognized electrical apprenticeship program preferred.<\/li><li>Journeyman Electrician license or equivalent certification required.<\/li><li>Minimum of 3 years of experience working with high voltage electrical systems, preferably in an industrial or mining environment.<\/li><li>Strong knowledge of electrical principles, codes, and regulations, with a focus on high voltage systems (4160V and above).<\/li><li>Ability to interpret electrical schematics, diagrams, and technical documentation.<\/li><li>Excellent problem-solving skills and attention to detail.<\/li><li>Effective communication and teamwork abilities.<\/li><li>Willingness to work in a dynamic and physically demanding environment, including outdoor and underground settings as required.<\/li><\/ul>\n<p><strong>Benefits:<\/strong><\/p>\n<ul><li>Competitive salary commensurate with experience.<\/li><li>Comprehensive benefits package, including medical, dental, vision, and retirement plans.<\/li><li>Opportunities for career growth and advancement within a leading mining organization.<\/li><li>Training and development programs to enhance your skills and knowledge.<\/li><li>A supportive work environment with a focus on safety and collaboration.<\/li><\/ul>\n<p><strong>How to Apply:<\/strong><br>If you are a qualified High Voltage Electrician looking for an exciting opportunity to contribute to the success of a dynamic mining operation, please submit your resume and cover letter through the Turner Staffing Group website!<\/p>\n<p>Turner Staffing Group is an equal opportunity employers committed to diversity and inclusion in the workplace.<\/p>","%category%":"Operations","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/9e5a721f0c7b-high-voltage-electrician","%breezy_id%":"9e5a721f0c7b","%breezy_friendly_id%":"9e5a721f0c7b-high-voltage-electrician","%breezy_created_date%":"2024-03-12T14:52:31.591Z","%breezy_updated_date%":"2025-02-11T15:55:00.078Z","%_wpgmp_location_city%":"Elko","%_wpgmp_location_state%":"NV","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Elko, NV, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"40.8436459","%_wpgmp_metabox_longitude%":"-115.7526187","%rank_math_internal_links_processed%":"1","%rank_math_analytic_object_id%":"59"}},"id":1216,"infowindow_disable":false},{"source":"post","title":"Heavy Equipment Mechanic","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Heavy Equipment Mechanic\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Heavy Equipment Mechanic Do you love mining? Do you think differently? Are you ready to define the future of this&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/heavy-equipment-mechanic-9\/\" name=\"Heavy Equipment Mechanic\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Heavy Equipment Mechanic Do you love mining? Do you think differently? Are you ready to define the future of this&hellip;","address":"Hadley, NV, USA","location":{"lat":"38.6943762","city":"Hadley","state":"NV","country":"United States","lng":"-117.160364","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/heavy-equipment-mechanic-9\/","zoom":19,"extra_fields":{"post_excerpt":"Heavy Equipment Mechanic Do you love mining? Do you think differently? Are you ready to define the future of this&hellip;","post_content":"<p><strong><u>Heavy Equipment Mechanic<\/u><\/strong><\/p>\n<p>Do you love mining? Do you think differently? Are you ready to define the future of this industry?<\/p>\n<p>We\u2019ve been waiting for you! Turner Staffing Group is committed to changing the way mining companies do business. We develop our people. We partner with our clients. We believe in win, win, win.<\/p>\n<p>We are looking for a dynamic and talented professional to fill a Heavy Equipment Mechanic role at our fast-growing, forward thinking mining services company.<\/p>\n<p>Turner Staffing Group is seeking an energetic professional who can leverage their Heavy Equipment knowledge to expand upon our fast-growing business, creating best practices for systems and scalable business processes to ensure profitable operations. This person will function as a Heavy Equipment Mechanic, willingness to do, learn, perform and improve any maintenance task. Tasks will be defined and evolve in all areas of mining operations to ensure preventative maintenance is practiced, repairs, equipment runs in the area of responsibility. You will report to and work with the Project Superintendent to develop heavy equipment procedures that will ensure safe operations. This is an opportunity to work as part of the operations team in a safe, productive, and fun environment.<\/p>\n<p><u><strong>You<\/strong><\/u><br>\nYou want to work for a services company that is rapidly changing the way the largest materials producers do business. You are motivated by solving problems and partnering with our clients and suppliers. You want to work with great people and enjoy being a part of a strong team. You are a knowledgeable Heavy Equipment Mechanic professional who is not afraid to jump into every detail. You want to be in a place where continuous learning and growth is the norm. You are adaptable and able to juggle multiple initiatives concurrently.<\/p>\n<p><strong><u>Essential Skills &amp; Knowledge<\/u><\/strong><\/p>\n<p>\u2022 Follow a consistent and regular schedule to perform various types of maintenance on heavy equipment and various pieces of machinery<\/p>\n<p>\u2022 Perform repairs on equipment using tools, machine tools and measuring instruments<\/p>\n<p>\u2022 Diagnose and troubleshoot fuel systems, electrical systems, hydraulic systems and propane systems<\/p>\n<p>\u2022 Conduct oil changes, lubrication of equipment, tire replacements, hose repairs, battery replacements and assorted services<\/p>\n<p>\u2022 Recondition and replace parts of the heavy equipment<\/p>\n<p>\u2022 Operate and test equipment<\/p>\n<p>\u2022 Diagnoses problem areas for any significant wear or tear on the equipment<\/p>\n<p>\u2022 Produce detailed service reports and repair logs<\/p>\n<p>\u2022 Follow all established procedures and protocols<\/p>\n<p>\u2022 Build positive relationships with internal and external teams<\/p>\n<p>\u2022 Perform additional duties as assigned<\/p>\n<p><strong><u>Benefits<\/u><\/strong><\/p>\n<p>Turner Staffing Group offers a competitive salary, an excellent work culture, career advancement opportunities. Our team offers a benefits program which includes Medical, Dental, Vision, Life, and a 401k with company match. We believe in a work life balance and established paid time off for major holidays.<\/p>\n<p>At Turner Staffing Group, we encourage and celebrate an inclusive environment for all employees and are proud to be an equal opportunity workplace and affirmative action employer.<\/p>","post_title":"Heavy Equipment Mechanic","post_link":"https:\/\/turnerstaffing.com\/position\/heavy-equipment-mechanic-9\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Associate","%location_country%":"United States","%location_city%":"Hadley","%location_state_id%":"NV","%location_state_name%":"Nevada","%location_city_state%":"Hadley, NV","%education%":"High School or equivalent","%department%":"","%description%":"<p><strong><u>Heavy Equipment Mechanic<\/u><\/strong><\/p>\n<p>Do you love mining? Do you think differently? Are you ready to define the future of this industry?<\/p>\n<p>We\u2019ve been waiting for you! Turner Staffing Group is committed to changing the way mining companies do business. We develop our people. We partner with our clients. We believe in win, win, win.<\/p>\n<p>We are looking for a dynamic and talented professional to fill a Heavy Equipment Mechanic role at our fast-growing, forward thinking mining services company.<\/p>\n<p>Turner Staffing Group is seeking an energetic professional who can leverage their Heavy Equipment knowledge to expand upon our fast-growing business, creating best practices for systems and scalable business processes to ensure profitable operations. This person will function as a Heavy Equipment Mechanic, willingness to do, learn, perform and improve any maintenance task. Tasks will be defined and evolve in all areas of mining operations to ensure preventative maintenance is practiced, repairs, equipment runs in the area of responsibility. You will report to and work with the Project Superintendent to develop heavy equipment procedures that will ensure safe operations. This is an opportunity to work as part of the operations team in a safe, productive, and fun environment.<\/p>\n<p><u><strong>You<\/strong><\/u><br>\nYou want to work for a services company that is rapidly changing the way the largest materials producers do business. You are motivated by solving problems and partnering with our clients and suppliers. You want to work with great people and enjoy being a part of a strong team. You are a knowledgeable Heavy Equipment Mechanic professional who is not afraid to jump into every detail. You want to be in a place where continuous learning and growth is the norm. You are adaptable and able to juggle multiple initiatives concurrently.<\/p>\n<p><strong><u>Essential Skills &amp; Knowledge<\/u><\/strong><\/p>\n<p>\u2022 Follow a consistent and regular schedule to perform various types of maintenance on heavy equipment and various pieces of machinery<\/p>\n<p>\u2022 Perform repairs on equipment using tools, machine tools and measuring instruments<\/p>\n<p>\u2022 Diagnose and troubleshoot fuel systems, electrical systems, hydraulic systems and propane systems<\/p>\n<p>\u2022 Conduct oil changes, lubrication of equipment, tire replacements, hose repairs, battery replacements and assorted services<\/p>\n<p>\u2022 Recondition and replace parts of the heavy equipment<\/p>\n<p>\u2022 Operate and test equipment<\/p>\n<p>\u2022 Diagnoses problem areas for any significant wear or tear on the equipment<\/p>\n<p>\u2022 Produce detailed service reports and repair logs<\/p>\n<p>\u2022 Follow all established procedures and protocols<\/p>\n<p>\u2022 Build positive relationships with internal and external teams<\/p>\n<p>\u2022 Perform additional duties as assigned<\/p>\n<p><strong><u>Benefits<\/u><\/strong><\/p>\n<p>Turner Staffing Group offers a competitive salary, an excellent work culture, career advancement opportunities. Our team offers a benefits program which includes Medical, Dental, Vision, Life, and a 401k with company match. We believe in a work life balance and established paid time off for major holidays.<\/p>\n<p>At Turner Staffing Group, we encourage and celebrate an inclusive environment for all employees and are proud to be an equal opportunity workplace and affirmative action employer.<\/p>","%category%":"Other","%breezy_id%":"c28e984fcb8d","%breezy_friendly_id%":"c28e984fcb8d-heavy-equipment-mechanic","%breezy_created_date%":"2023-11-27T15:16:09.094Z","%breezy_updated_date%":"2025-02-13T15:52:59.685Z","%rank_math_internal_links_processed%":"1","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/c28e984fcb8d-heavy-equipment-mechanic","%_wpgmp_location_city%":"Hadley","%_wpgmp_location_state%":"NV","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Hadley, NV, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"38.6943762","%_wpgmp_metabox_longitude%":"-117.160364","%rank_math_analytic_object_id%":"81"}},"id":883,"infowindow_disable":false},{"source":"post","title":"Heavy Equipment Mechanic","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Heavy Equipment Mechanic\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Heavy Equipment Mechanic&nbsp; Do you love mining? Do you think differently? Are you ready to define the future of this&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/heavy-equipment-mechanic-3\/\" name=\"Heavy Equipment Mechanic\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Heavy Equipment Mechanic&nbsp; Do you love mining? Do you think differently? Are you ready to define the future of this&hellip;","address":"Elko, NV, USA","location":{"lat":"40.8436459","city":"Elko","state":"NV","country":"United States","lng":"-115.7526187","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/heavy-equipment-mechanic-3\/","zoom":19,"extra_fields":{"post_excerpt":"Heavy Equipment Mechanic&nbsp; Do you love mining? Do you think differently? Are you ready to define the future of this&hellip;","post_content":"<p style=\"color:#000000\"><strong><u>Heavy Equipment Mechanic&nbsp;<\/u><\/strong><\/p>\n<p style=\"color:#000000\"><span style=\"color:#333333\">Do you love mining? Do you think differently? Are you ready to define the future of this industry?<\/span><\/p>\n<p style=\"color:#000000\"><span style=\"color:#333333\">We\u2019ve been waiting for you! Turner Staffing&nbsp;Group is committed to changing the way mining companies do business. We develop our people. We partner with our clients. We believe in win, win, win.<\/span><\/p>\n<p>We are looking for a dynamic and talented professional to fill a Heavy Equipment Mechanic role at our fast-growing, forward thinking mining services company.<\/p>\n<p style=\"color:#000000\"><span style=\"color:#333333\">Turner Staffing&nbsp;Group is seeking an energetic professional who can leverage their Heavy Equipment knowledge to expand upon our fast-growing business, creating best practices for systems and scalable business processes to ensure profitable operations. This person will function as a Heavy Equipment Mechanic, willingness to do, learn, perform and improve any maintenance task. Tasks will be defined and evolve in all areas of mining operations to ensure preventative maintenance is practiced, repairs, equipment runs in the area of responsibility. You will report to and work with the Project Superintendent to develop heavy equipment procedures that will ensure safe operations. This is an opportunity to work as part of the operations team in a safe, productive, and fun environment.<\/span><\/p>\n<p style=\"color:#000000\"><strong><span style=\"color:#333333\">You<br><\/span><\/strong><span style=\"color:#333333\">You want to work for a services company that is rapidly changing the way the largest materials producers do business. You are motivated by solving problems and partnering with our clients and suppliers. You want to work with great people and enjoy being a part of a strong team. You are a knowledgeable Heavy Equipment Mechanic professional who is not afraid to jump into every detail. You want to be in a place where continuous learning and growth is the norm. You are adaptable and able to juggle multiple initiatives concurrently.<\/span><\/p>\n<p style=\"color:#000000\"><strong><span style=\"color:#333333\">Essential Skills &amp; Knowledge<\/span><\/strong><\/p>\n<p style=\"color:#000000\"><span style=\"color:#333333\">\u2022 Follow a consistent and regular schedule to perform various types of maintenance on heavy equipment and various pieces of machinery<\/span><\/p>\n<p style=\"color:#000000\"><span style=\"color:#333333\">\u2022 Perform repairs on equipment using tools, machine tools and measuring instruments<\/span><\/p>\n<p style=\"color:#000000\"><span style=\"color:#333333\">\u2022 Diagnose and troubleshoot fuel systems, electrical systems, hydraulic systems and propane systems<\/span><\/p>\n<p style=\"color:#000000\"><span style=\"color:#333333\">\u2022 Conduct oil changes, lubrication of equipment, tire replacements, hose repairs, battery replacements and assorted services<\/span><\/p>\n<p style=\"color:#000000\"><span style=\"color:#333333\">\u2022 Recondition and replace parts of the heavy equipment<\/span><\/p>\n<p style=\"color:#000000\"><span style=\"color:#333333\">\u2022 Operate and test equipment<\/span><\/p>\n<p style=\"color:#000000\"><span style=\"color:#333333\">\u2022 Diagnoses problem areas for any significant wear or tear on the equipment<\/span><\/p>\n<p style=\"color:#000000\"><span style=\"color:#333333\">\u2022 Produce detailed service reports and repair logs<\/span><\/p>\n<p style=\"color:#000000\"><span style=\"color:#333333\">\u2022 Follow all established procedures and protocols<\/span><\/p>\n<p style=\"color:#000000\"><span style=\"color:#333333\">\u2022 Build positive relationships with internal and external teams<\/span><\/p>\n<p style=\"color:#000000\"><span style=\"color:#333333\">\u2022 Perform additional duties as assigned<\/span><\/p>\n<p style=\"color:#000000\"><strong><span style=\"color:#333333\">Benefits<\/span><\/strong><\/p>\n<p style=\"color:#000000\"><span style=\"color:#333333\">Turner Staffing Group offers a competitive salary, an excellent work culture, career advancement opportunities. Our team offers a benefits program which includes Medical, Dental, Vision, Life, and a 401k with company match. We believe in a work life balance and established paid time off for major holidays.<\/span><\/p>\n<p style=\"color:#000000\"><span style=\"color:#333333\">At Turner Staffing Group, we encourage and celebrate an inclusive environment for all employees and are proud to be an equal opportunity workplace and affirmative action employer.<\/span><\/p>","post_title":"Heavy Equipment Mechanic","post_link":"https:\/\/turnerstaffing.com\/position\/heavy-equipment-mechanic-3\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"","%location_country%":"United States","%location_city%":"Elko","%location_state_id%":"NV","%location_state_name%":"Nevada","%location_city_state%":"Elko, NV","%education%":"","%department%":"","%description%":"<p style=\"color:#000000;\"><strong><u>Heavy Equipment Mechanic&nbsp;<\/u><\/strong><\/p>\n<p style=\"color:#000000;\"><span style=\"color:#333333;\">Do you love mining? Do you think differently? Are you ready to define the future of this industry?<\/span><\/p>\n<p style=\"color:#000000;\"><span style=\"color:#333333;\">We\u2019ve been waiting for you! Turner Staffing&nbsp;Group is committed to changing the way mining companies do business. We develop our people. We partner with our clients. We believe in win, win, win.<\/span><\/p>\n<p>We are looking for a dynamic and talented professional to fill a Heavy Equipment Mechanic role at our fast-growing, forward thinking mining services company.<\/p>\n<p style=\"color:#000000;\"><span style=\"color:#333333;\">Turner Staffing&nbsp;Group is seeking an energetic professional who can leverage their Heavy Equipment knowledge to expand upon our fast-growing business, creating best practices for systems and scalable business processes to ensure profitable operations. This person will function as a Heavy Equipment Mechanic, willingness to do, learn, perform and improve any maintenance task. Tasks will be defined and evolve in all areas of mining operations to ensure preventative maintenance is practiced, repairs, equipment runs in the area of responsibility. You will report to and work with the Project Superintendent to develop heavy equipment procedures that will ensure safe operations. This is an opportunity to work as part of the operations team in a safe, productive, and fun environment.<\/span><\/p>\n<p style=\"color:#000000;\"><strong><span style=\"color:#333333;\">You<br><\/span><\/strong><span style=\"color:#333333;\">You want to work for a services company that is rapidly changing the way the largest materials producers do business. You are motivated by solving problems and partnering with our clients and suppliers. You want to work with great people and enjoy being a part of a strong team. You are a knowledgeable Heavy Equipment Mechanic professional who is not afraid to jump into every detail. You want to be in a place where continuous learning and growth is the norm. You are adaptable and able to juggle multiple initiatives concurrently.<\/span><\/p>\n<p style=\"color:#000000;\"><strong><span style=\"color:#333333;\">Essential Skills &amp; Knowledge<\/span><\/strong><\/p>\n<p style=\"color:#000000;\"><span style=\"color:#333333;\">\u2022 Follow a consistent and regular schedule to perform various types of maintenance on heavy equipment and various pieces of machinery<\/span><\/p>\n<p style=\"color:#000000;\"><span style=\"color:#333333;\">\u2022 Perform repairs on equipment using tools, machine tools and measuring instruments<\/span><\/p>\n<p style=\"color:#000000;\"><span style=\"color:#333333;\">\u2022 Diagnose and troubleshoot fuel systems, electrical systems, hydraulic systems and propane systems<\/span><\/p>\n<p style=\"color:#000000;\"><span style=\"color:#333333;\">\u2022 Conduct oil changes, lubrication of equipment, tire replacements, hose repairs, battery replacements and assorted services<\/span><\/p>\n<p style=\"color:#000000;\"><span style=\"color:#333333;\">\u2022 Recondition and replace parts of the heavy equipment<\/span><\/p>\n<p style=\"color:#000000;\"><span style=\"color:#333333;\">\u2022 Operate and test equipment<\/span><\/p>\n<p style=\"color:#000000;\"><span style=\"color:#333333;\">\u2022 Diagnoses problem areas for any significant wear or tear on the equipment<\/span><\/p>\n<p style=\"color:#000000;\"><span style=\"color:#333333;\">\u2022 Produce detailed service reports and repair logs<\/span><\/p>\n<p style=\"color:#000000;\"><span style=\"color:#333333;\">\u2022 Follow all established procedures and protocols<\/span><\/p>\n<p style=\"color:#000000;\"><span style=\"color:#333333;\">\u2022 Build positive relationships with internal and external teams<\/span><\/p>\n<p style=\"color:#000000;\"><span style=\"color:#333333;\">\u2022 Perform additional duties as assigned<\/span><\/p>\n<p style=\"color:#000000;\"><strong><span style=\"color:#333333;\">Benefits<\/span><\/strong><\/p>\n<p style=\"color:#000000;\"><span style=\"color:#333333;\">Turner Staffing Group offers a competitive salary, an excellent work culture, career advancement opportunities. Our team offers a benefits program which includes Medical, Dental, Vision, Life, and a 401k with company match. We believe in a work life balance and established paid time off for major holidays.<\/span><\/p>\n<p style=\"color:#000000;\"><span style=\"color:#333333;\">At Turner Staffing Group, we encourage and celebrate an inclusive environment for all employees and are proud to be an equal opportunity workplace and affirmative action employer.<\/span><\/p>","%category%":"Operations","%breezy_id%":"812c4428ce1b","%breezy_friendly_id%":"812c4428ce1b-heavy-equipment-mechanic","%breezy_created_date%":"2023-03-09T17:38:02.991Z","%breezy_updated_date%":"2025-03-12T14:13:39.489Z","%rank_math_internal_links_processed%":"1","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/812c4428ce1b-heavy-equipment-mechanic","%_wpgmp_location_city%":"Elko","%_wpgmp_location_state%":"NV","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Elko, NV, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"40.8436459","%_wpgmp_metabox_longitude%":"-115.7526187","%rank_math_analytic_object_id%":"135"}},"id":833,"infowindow_disable":false}],"styles":"[{\"featureType\":\"water\",\"elementType\":\"geometry\",\"stylers\":[{\"color\":\"#e9e9e9\"},{\"lightness\":17}]},{\"featureType\":\"landscape\",\"elementType\":\"geometry\",\"stylers\":[{\"color\":\"#f5f5f5\"},{\"lightness\":20}]},{\"featureType\":\"road.highway\",\"elementType\":\"geometry.fill\",\"stylers\":[{\"color\":\"#ffffff\"},{\"lightness\":17}]},{\"featureType\":\"road.highway\",\"elementType\":\"geometry.stroke\",\"stylers\":[{\"color\":\"#ffffff\"},{\"lightness\":29},{\"weight\":0.2}]},{\"featureType\":\"road.arterial\",\"elementType\":\"geometry\",\"stylers\":[{\"color\":\"#ffffff\"},{\"lightness\":18}]},{\"featureType\":\"road.local\",\"elementType\":\"geometry\",\"stylers\":[{\"color\":\"#ffffff\"},{\"lightness\":16}]},{\"featureType\":\"poi\",\"elementType\":\"geometry\",\"stylers\":[{\"color\":\"#f5f5f5\"},{\"lightness\":21}]},{\"featureType\":\"poi.park\",\"elementType\":\"geometry\",\"stylers\":[{\"color\":\"#dedede\"},{\"lightness\":21}]},{\"elementType\":\"labels.text.stroke\",\"stylers\":[{\"visibility\":\"on\"},{\"color\":\"#ffffff\"},{\"lightness\":16}]},{\"elementType\":\"labels.text.fill\",\"stylers\":[{\"saturation\":36},{\"color\":\"#333333\"},{\"lightness\":40}]},{\"elementType\":\"labels.icon\",\"stylers\":[{\"visibility\":\"off\"}]},{\"featureType\":\"transit\",\"elementType\":\"geometry\",\"stylers\":[{\"color\":\"#f2f2f2\"},{\"lightness\":19}]},{\"featureType\":\"administrative\",\"elementType\":\"geometry.fill\",\"stylers\":[{\"color\":\"#fefefe\"},{\"lightness\":20}]},{\"featureType\":\"administrative\",\"elementType\":\"geometry.stroke\",\"stylers\":[{\"color\":\"#fefefe\"},{\"lightness\":17},{\"weight\":1.2}]}]","listing":{"listing_header":" ","display_search_form":true,"search_field_autosuggest":false,"display_category_filter":true,"display_sorting_filter":false,"display_radius_filter":false,"radius_dimension":"miles","radius_options":"10,50,100,200,300","apply_default_radius":false,"default_radius_dimension":"miles","display_location_per_page_filter":false,"display_print_option":false,"display_grid_option":false,"filters":["place_category"],"sorting_options":{"category__asc":"A-Z Category","category__desc":"Z-A Category","title__asc":"A-Z Title","title__desc":"Z-A Title","address__asc":"A-Z Address","address__desc":"Z-A Address"},"default_sorting":{"orderby":"title","inorder":"asc"},"listing_container":".location_listing1","tabs_container":".location_listing1","hide_locations":false,"filters_position":"default","hide_map":false,"pagination":{"listing_per_page":"50"},"list_grid":"wpgmp_listing_list","listing_placeholder":"<li class=\"tsg-jb-listing-container\">\r\n  <div class=\"tsg-jb-name\">\r\n    {post_title}\r\n  <\/div>\r\n  <div class=\"tsg-jb-location\">\r\n    {marker_city}, {marker_state}\r\n  <\/div>\r\n  <div class=\"tsg-jb-link\">\r\n    <a href=\"{post_link}\" name=\"{post_title}\"><button class=\"button tsg-button-outline\">View\r\n  <\/button><\/a><\/div><a href=\"{post_link}\" name=\"{post_title}\">\r\n<\/a><\/li>","list_item_skin":{"name":"default","type":"item","sourcecode":"&lt;li class=&quot;tsg-jb-listing-container&quot;&gt;\r\n  &lt;div class=&quot;tsg-jb-name&quot;&gt;\r\n    {post_title}\r\n  &lt;\/div&gt;\r\n  &lt;div class=&quot;tsg-jb-location&quot;&gt;\r\n    {marker_city}, {marker_state}\r\n  &lt;\/div&gt;\r\n  &lt;div class=&quot;tsg-jb-link&quot;&gt;\r\n    &lt;a href=&quot;{post_link}&quot; name=&quot;{post_title}&quot;&gt;&lt;button class=&quot;button tsg-button-outline&quot;&gt;View\r\n  &lt;\/button&gt;&lt;\/a&gt;&lt;\/div&gt;&lt;a href=&quot;{post_link}&quot; name=&quot;{post_title}&quot;&gt;\r\n&lt;\/a&gt;&lt;\/li&gt;"}},"map_property":{"map_id":"1","debug_mode":false},"map_marker_spiderfier_setting":{"minimum_markers":"0"},"shapes":{"drawing_editable":false},"filters":{"custom_filters":{"filters":{"dropdown":{"city":"Cities","state":"States"}}},"filters_container":"[data-container=\"wpgmp-filters-container\"]"}}