Job Board

{"map_options":{"center_lat":"36.171563","center_lng":"-115.1391009","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":"Laboratory Manager","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Laboratory Manager\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Laboratory Manager \u2013 Geotechnical &amp; Construction Materials Testing Location: Las Vegas, NV Status: Full-Time | On-Site We are seeking an&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/laboratory-manager\/\" name=\"Laboratory Manager\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Laboratory Manager \u2013 Geotechnical &amp; Construction Materials Testing Location: Las Vegas, NV Status: Full-Time | On-Site We are seeking an&hellip;","address":"Las Vegas, NV, USA","location":{"lat":"36.171563","city":"Las Vegas","state":"NV","country":"United States","lng":"-115.1391009","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/laboratory-manager\/","zoom":19,"extra_fields":{"post_excerpt":"Laboratory Manager \u2013 Geotechnical &amp; Construction Materials Testing Location: Las Vegas, NV Status: Full-Time | On-Site We are seeking an&hellip;","post_content":"<p><strong>Laboratory Manager \u2013 Geotechnical &amp; Construction Materials Testing<\/strong><br>\n<strong>Location:<\/strong> Las Vegas, NV<br>\n<strong>Status:<\/strong> Full-Time | On-Site<\/p>\n<p>We are seeking an experienced <strong>Laboratory Manager<\/strong> to lead day-to-day operations of our geotechnical and construction materials testing laboratory in Las Vegas. This role is responsible for overseeing all laboratory testing activities, ensuring compliance with applicable standards, and managing staff, equipment, and workflow to support project execution.<\/p>\n<h3>Key Responsibilities<\/h3>\n<ul>\n<li>\n<p>Manage and oversee all laboratory operations, including testing of <strong>soils, asphalt, and concrete<\/strong><\/p>\n<\/li>\n<li>\n<p>Ensure strict adherence to applicable <strong>ASTM, AASHTO, and other governing test standards<\/strong><\/p>\n<\/li>\n<li>\n<p>Supervise, train, and mentor laboratory technicians and staff<\/p>\n<\/li>\n<li>\n<p>Maintain complete, accurate, and organized laboratory records and test data<\/p>\n<\/li>\n<li>\n<p>Oversee laboratory certifications, audits, and compliance requirements<\/p>\n<\/li>\n<li>\n<p>Manage laboratory equipment, including maintenance, calibration, and procurement<\/p>\n<\/li>\n<li>\n<p>Control laboratory budgets, workflow scheduling, and resource allocation<\/p>\n<\/li>\n<li>\n<p>Coordinate closely with Project Managers to ensure clear communication on testing scope, schedules, and deliverables<\/p>\n<\/li>\n<li>\n<p>Ensure timely, accurate, and well-organized project documentation and reporting<\/p>\n<\/li>\n<\/ul>\n<h3>Required Qualifications<\/h3>\n<ul>\n<li>\n<p>Hands-on experience in <strong>soil, asphalt, and concrete testing<\/strong><\/p>\n<\/li>\n<li>\n<p>Minimum <strong>5+ years of relevant laboratory experience<\/strong> preferred<\/p>\n<\/li>\n<li>\n<p>Strong leadership, organizational, and communication skills<\/p>\n<\/li>\n<li>\n<p>Demonstrated ability to manage staff, priorities, and deadlines<\/p>\n<\/li>\n<li>\n<p>Positive attitude, strong work ethic, and attention to detail<\/p>\n<\/li>\n<li>\n<p>Valid driver\u2019s license<\/p>\n<\/li>\n<\/ul>\n<h3>Certifications<\/h3>\n<ul>\n<li>\n<p><strong>ACI Certifications<\/strong>, including:<\/p>\n<ul>\n<li>\n<p>Concrete Strength Testing Technician<\/p>\n<\/li>\n<li>\n<p>Concrete Field Testing Technician \u2013 Grade I<\/p>\n<\/li>\n<li>\n<p>Aggregate Testing Technician \u2013 Level 1<\/p>\n<\/li>\n<li>\n<p>Aggregate Base Testing Technician<\/p>\n<\/li>\n<li>\n<p>Aggregate Testing Technician \u2013 Level 2<\/p>\n<\/li>\n<li>\n<p>Masonry Laboratory Testing Technician<\/p>\n<\/li>\n<\/ul>\n<\/li>\n<li>\n<p><strong>NAQTC Certifications<\/strong>, including:<\/p>\n<ul>\n<li>\n<p>Sampling and Density<\/p>\n<\/li>\n<li>\n<p>Aggregate<\/p>\n<\/li>\n<li>\n<p>Asphalt<\/p>\n<\/li>\n<li>\n<p>Asphalt Extended Testing<\/p><\/li><\/ul><\/li><\/ul>","post_title":"Laboratory Manager","post_link":"https:\/\/turnerstaffing.com\/position\/laboratory-manager\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"","%location_country%":"United States","%location_city%":"Las Vegas","%location_state_id%":"NV","%location_state_name%":"Nevada","%location_city_state%":"Las Vegas, NV","%education%":"","%department%":"","%description%":"<p><strong>Laboratory Manager \u2013 Geotechnical &amp; Construction Materials Testing<\/strong><br>\n<strong>Location:<\/strong> Las Vegas, NV<br>\n<strong>Status:<\/strong> Full-Time | On-Site<\/p>\n<p>We are seeking an experienced <strong>Laboratory Manager<\/strong> to lead day-to-day operations of our geotechnical and construction materials testing laboratory in Las Vegas. This role is responsible for overseeing all laboratory testing activities, ensuring compliance with applicable standards, and managing staff, equipment, and workflow to support project execution.<\/p>\n<h3>Key Responsibilities<\/h3>\n<ul>\n<li>\n<p>Manage and oversee all laboratory operations, including testing of <strong>soils, asphalt, and concrete<\/strong><\/p>\n<\/li>\n<li>\n<p>Ensure strict adherence to applicable <strong>ASTM, AASHTO, and other governing test standards<\/strong><\/p>\n<\/li>\n<li>\n<p>Supervise, train, and mentor laboratory technicians and staff<\/p>\n<\/li>\n<li>\n<p>Maintain complete, accurate, and organized laboratory records and test data<\/p>\n<\/li>\n<li>\n<p>Oversee laboratory certifications, audits, and compliance requirements<\/p>\n<\/li>\n<li>\n<p>Manage laboratory equipment, including maintenance, calibration, and procurement<\/p>\n<\/li>\n<li>\n<p>Control laboratory budgets, workflow scheduling, and resource allocation<\/p>\n<\/li>\n<li>\n<p>Coordinate closely with Project Managers to ensure clear communication on testing scope, schedules, and deliverables<\/p>\n<\/li>\n<li>\n<p>Ensure timely, accurate, and well-organized project documentation and reporting<\/p>\n<\/li>\n<\/ul>\n<h3>Required Qualifications<\/h3>\n<ul>\n<li>\n<p>Hands-on experience in <strong>soil, asphalt, and concrete testing<\/strong><\/p>\n<\/li>\n<li>\n<p>Minimum <strong>5+ years of relevant laboratory experience<\/strong> preferred<\/p>\n<\/li>\n<li>\n<p>Strong leadership, organizational, and communication skills<\/p>\n<\/li>\n<li>\n<p>Demonstrated ability to manage staff, priorities, and deadlines<\/p>\n<\/li>\n<li>\n<p>Positive attitude, strong work ethic, and attention to detail<\/p>\n<\/li>\n<li>\n<p>Valid driver\u2019s license<\/p>\n<\/li>\n<\/ul>\n<h3>Certifications<\/h3>\n<ul>\n<li>\n<p><strong>ACI Certifications<\/strong>, including:<\/p>\n<ul>\n<li>\n<p>Concrete Strength Testing Technician<\/p>\n<\/li>\n<li>\n<p>Concrete Field Testing Technician \u2013 Grade I<\/p>\n<\/li>\n<li>\n<p>Aggregate Testing Technician \u2013 Level 1<\/p>\n<\/li>\n<li>\n<p>Aggregate Base Testing Technician<\/p>\n<\/li>\n<li>\n<p>Aggregate Testing Technician \u2013 Level 2<\/p>\n<\/li>\n<li>\n<p>Masonry Laboratory Testing Technician<\/p>\n<\/li>\n<\/ul>\n<\/li>\n<li>\n<p><strong>NAQTC Certifications<\/strong>, including:<\/p>\n<ul>\n<li>\n<p>Sampling and Density<\/p>\n<\/li>\n<li>\n<p>Aggregate<\/p>\n<\/li>\n<li>\n<p>Asphalt<\/p>\n<\/li>\n<li>\n<p>Asphalt Extended Testing<\/p><\/li><\/ul><\/li><\/ul>","%category%":"Operations","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/80c765f67500-laboratory-manager","%breezy_id%":"80c765f67500","%breezy_friendly_id%":"80c765f67500-laboratory-manager","%breezy_created_date%":"2026-02-04T19:49:39.930Z","%breezy_updated_date%":"2026-02-04T19:50:24.574Z","%_wpgmp_location_city%":"Las Vegas","%_wpgmp_location_state%":"NV","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Las Vegas, NV, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"36.171563","%_wpgmp_metabox_longitude%":"-115.1391009","%rank_math_internal_links_processed%":"1"}},"id":3126,"infowindow_disable":false},{"source":"post","title":"HR Director","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    HR Director\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Position Overview Turner Mining Group is seeking an experienced and strategic Human Resources Director to lead and manage all aspects&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/hr-director\/\" name=\"HR Director\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Position Overview Turner Mining Group is seeking an experienced and strategic Human Resources Director to lead and manage all aspects&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\/hr-director\/","zoom":19,"extra_fields":{"post_excerpt":"Position Overview Turner Mining Group is seeking an experienced and strategic Human Resources Director to lead and manage all aspects&hellip;","post_content":"<h3>Position Overview<\/h3>\n<p>Turner Mining Group is seeking an experienced and strategic <strong>Human Resources Director<\/strong> to lead and manage all aspects of human resources for our growing contract mining organization. This role will be based in our Bloomington, Indiana home office and will serve as a key member of the leadership team, supporting both field operations and corporate functions across multiple project sites.<\/p>\n<p>The Human Resources Director will be responsible for developing and executing HR strategies that align with business objectives, ensure compliance, strengthen workforce development, and promote a strong safety- and performance-driven culture.<\/p>\n<h3>Key Responsibilities<\/h3>\n<ul>\n<li>\n<p>Lead and oversee all HR functions, including recruitment, onboarding, employee relations, performance management, compensation, benefits, and training<\/p>\n<\/li>\n<li>\n<p>Partner with executive leadership to develop and implement HR strategies that support company growth and operational needs<\/p>\n<\/li>\n<li>\n<p>Ensure compliance with all federal, state, and local employment laws and regulations, including those relevant to mining and construction environments<\/p>\n<\/li>\n<li>\n<p>Manage talent acquisition efforts for both salaried and hourly roles across corporate and field operations<\/p>\n<\/li>\n<li>\n<p>Develop and maintain HR policies, procedures, and employee handbook updates<\/p>\n<\/li>\n<li>\n<p>Provide guidance and support to managers on employee relations matters, disciplinary actions, and performance issues<\/p>\n<\/li>\n<li>\n<p>Oversee benefits administration, payroll coordination, and HRIS systems<\/p>\n<\/li>\n<li>\n<p>Lead workforce planning, succession planning, and employee development initiatives<\/p>\n<\/li>\n<li>\n<p>Support safety culture initiatives in coordination with operations and safety leadership<\/p>\n<\/li>\n<li>\n<p>Analyze HR metrics and trends to support data-driven decision-making<\/p>\n<\/li>\n<li>\n<p>Manage and mentor HR staff as the department grows<\/p>\n<\/li>\n<\/ul>\n<h3>Qualifications<\/h3>\n<ul>\n<li>\n<p>Bachelor\u2019s degree in Human Resources, Business Administration, or a related field (Master\u2019s degree preferred)<\/p>\n<\/li>\n<li>\n<p>8+ years of progressive HR experience, with at least 3\u20135 years in a leadership or director-level role<\/p>\n<\/li>\n<li>\n<p>Experience in mining, construction, heavy civil, or industrial environments strongly preferred<\/p>\n<\/li>\n<li>\n<p>Strong knowledge of employment law, compliance, and best HR practices<\/p>\n<\/li>\n<li>\n<p>Proven ability to work effectively with field-based and corporate teams<\/p>\n<\/li>\n<li>\n<p>Excellent leadership, communication, and problem-solving skills<\/p>\n<\/li>\n<li>\n<p>Experience supporting multi-state or multi-site operations preferred<\/p>\n<\/li>\n<li>\n<p>SHRM-SCP, SPHR, or similar professional certification a plus<\/p>\n<\/li>\n<\/ul>\n<h3>What We Offer<\/h3>\n<ul>\n<li>\n<p>Competitive salary and benefits package<\/p>\n<\/li>\n<li>\n<p>Opportunity to play a key leadership role in a growing, dynamic mining services company<\/p>\n<\/li>\n<li>\n<p>Collaborative, team-oriented work environment<\/p>\n<\/li>\n<li>\n<p>Long-term career growth and professional development opportunities<\/p><\/li><\/ul>","post_title":"HR Director","post_link":"https:\/\/turnerstaffing.com\/position\/hr-director\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Senior","%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%":"","%description%":"<h3>Position Overview<\/h3>\n<p>Turner Mining Group is seeking an experienced and strategic <strong>Human Resources Director<\/strong> to lead and manage all aspects of human resources for our growing contract mining organization. This role will be based in our Bloomington, Indiana home office and will serve as a key member of the leadership team, supporting both field operations and corporate functions across multiple project sites.<\/p>\n<p>The Human Resources Director will be responsible for developing and executing HR strategies that align with business objectives, ensure compliance, strengthen workforce development, and promote a strong safety- and performance-driven culture.<\/p>\n<h3>Key Responsibilities<\/h3>\n<ul>\n<li>\n<p>Lead and oversee all HR functions, including recruitment, onboarding, employee relations, performance management, compensation, benefits, and training<\/p>\n<\/li>\n<li>\n<p>Partner with executive leadership to develop and implement HR strategies that support company growth and operational needs<\/p>\n<\/li>\n<li>\n<p>Ensure compliance with all federal, state, and local employment laws and regulations, including those relevant to mining and construction environments<\/p>\n<\/li>\n<li>\n<p>Manage talent acquisition efforts for both salaried and hourly roles across corporate and field operations<\/p>\n<\/li>\n<li>\n<p>Develop and maintain HR policies, procedures, and employee handbook updates<\/p>\n<\/li>\n<li>\n<p>Provide guidance and support to managers on employee relations matters, disciplinary actions, and performance issues<\/p>\n<\/li>\n<li>\n<p>Oversee benefits administration, payroll coordination, and HRIS systems<\/p>\n<\/li>\n<li>\n<p>Lead workforce planning, succession planning, and employee development initiatives<\/p>\n<\/li>\n<li>\n<p>Support safety culture initiatives in coordination with operations and safety leadership<\/p>\n<\/li>\n<li>\n<p>Analyze HR metrics and trends to support data-driven decision-making<\/p>\n<\/li>\n<li>\n<p>Manage and mentor HR staff as the department grows<\/p>\n<\/li>\n<\/ul>\n<h3>Qualifications<\/h3>\n<ul>\n<li>\n<p>Bachelor\u2019s degree in Human Resources, Business Administration, or a related field (Master\u2019s degree preferred)<\/p>\n<\/li>\n<li>\n<p>8+ years of progressive HR experience, with at least 3\u20135 years in a leadership or director-level role<\/p>\n<\/li>\n<li>\n<p>Experience in mining, construction, heavy civil, or industrial environments strongly preferred<\/p>\n<\/li>\n<li>\n<p>Strong knowledge of employment law, compliance, and best HR practices<\/p>\n<\/li>\n<li>\n<p>Proven ability to work effectively with field-based and corporate teams<\/p>\n<\/li>\n<li>\n<p>Excellent leadership, communication, and problem-solving skills<\/p>\n<\/li>\n<li>\n<p>Experience supporting multi-state or multi-site operations preferred<\/p>\n<\/li>\n<li>\n<p>SHRM-SCP, SPHR, or similar professional certification a plus<\/p>\n<\/li>\n<\/ul>\n<h3>What We Offer<\/h3>\n<ul>\n<li>\n<p>Competitive salary and benefits package<\/p>\n<\/li>\n<li>\n<p>Opportunity to play a key leadership role in a growing, dynamic mining services company<\/p>\n<\/li>\n<li>\n<p>Collaborative, team-oriented work environment<\/p>\n<\/li>\n<li>\n<p>Long-term career growth and professional development opportunities<\/p><\/li><\/ul>","%category%":"Human Resources","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/86a1273f19a8-hr-director","%breezy_id%":"86a1273f19a8","%breezy_friendly_id%":"86a1273f19a8-hr-director","%breezy_created_date%":"2026-02-04T14:06:18.070Z","%breezy_updated_date%":"2026-02-04T14:07:07.265Z","%_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":3123,"infowindow_disable":false},{"source":"post","title":"Diagnostic Electrician &#8211; Smelter","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Diagnostic Electrician &#8211; Smelter\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Where You Will Work\u202f\u202f&nbsp;&nbsp; Our Miami smelter and rod plant is nestled just 90 miles east of Phoenix. The smelter&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/diagnostic-electrician-smelter\/\" name=\"Diagnostic Electrician &#8211; Smelter\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Where You Will Work\u202f\u202f&nbsp;&nbsp; Our Miami smelter and rod plant is nestled just 90 miles east of Phoenix. The smelter&hellip;","address":"Miami, AZ, USA","location":{"lat":"33.3992217","city":"Miami","state":"AZ","country":"United States","lng":"-110.8687232","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/diagnostic-electrician-smelter\/","zoom":19,"extra_fields":{"post_excerpt":"Where You Will Work\u202f\u202f&nbsp;&nbsp; Our Miami smelter and rod plant is nestled just 90 miles east of Phoenix. The smelter&hellip;","post_content":"<p><strong>Where You Will Work\u202f\u202f&nbsp;<\/strong>&nbsp;<\/p>\n<p>Our Miami smelter and rod plant is nestled just 90 miles east of Phoenix. The smelter processes copper concentrate primarily from our company\u2019s Arizona copper mines and is the most significant source of sulfuric acid for our North American leaching operations. Arizona\u2019s Globe-Miami\u202fhistoric mining district offers natural beauty and a rich mining heritage.&nbsp;&nbsp;<\/p>\n<p><strong>What You Will Do<\/strong>&nbsp;<\/p>\n<ul><li>Removal, repair and installation of electrical components, electrical systems, analysis and diagnosis, advanced&nbsp;troubleshooting&nbsp;and systems\/process optimization; may mentor or train other electrical workers&nbsp;<\/li><\/ul>\n<ul><li>Safe completion of routine and non-routine repairs and construction&nbsp;<\/li><\/ul>\n<ul><li>Perform preventative maintenance including installation, repair and troubleshooting of&nbsp;industrical&nbsp;electrical and\/or instrumentation equipment (i.e.&nbsp;substations, power distribution systems, switchgear motors, motor controls, systems and components, process controls,&nbsp;instrumentation&nbsp;and pneumatic equipment)&nbsp;<\/li><\/ul>\n<ul><li>Must have strong knowledge in the maintenance and troubleshooting of AC\/DC drives, PLCs, overhead cranes, management control systems, calibration of field transmitters\/transducers and weigh scales, and low and medium voltage equipment&nbsp;<\/li><\/ul>\n<ul><li>Ability to perform installations and renovations compliant with regulatory agency standards&nbsp;<\/li><\/ul>\n<ul><li>Follow Standard Operating&nbsp;Procedues&nbsp;(SOP) and work area instructions,&nbsp;participate&nbsp;in safety and environmental activities, and&nbsp;use plant and equipment correctly at all times&nbsp;<\/li><\/ul>\n<p><strong>What You Bring&nbsp;<\/strong>&nbsp;<\/p>\n<ul><li>Completion of an approved Certified Electronics, Electrical and\/or Instrumentation Program,\u202f<strong>OR&nbsp;<\/strong>&nbsp;<\/li><\/ul>\n<ul><li>Minimum of four (4) years of experience in Industrial Electrical and\/or Instrumentation repair and maintenance,\u202f<strong>OR&nbsp;<\/strong>&nbsp;<\/li><\/ul>\n<ul><li>Associate's degree or Trade School Certification in a related field\u202f<strong>and\u202f<\/strong>two (2) years of experience in Industrial Electrical and\/or Instrumentation repair and maintenance&nbsp;&nbsp;<\/li><\/ul>\n<ul><li>Experience in troubleshooting, maintenance and repair of electrical circuits and connected equipment; this includes the ability to read, understand and apply information from technical manuals, prints, and schematics for trouble shooting and repair&nbsp;&nbsp;<\/li><\/ul>\n<ul><li>Effective written and verbal communication skills to satisfy training, safety, and electronic message transmission policies of the company&nbsp;&nbsp;<\/li><\/ul>\n<ul><li>Must have&nbsp;minimum&nbsp;personal tools as described by the department tool list or be able to obtain them within&nbsp;90 days&nbsp;of hire date&nbsp;&nbsp;<\/li><\/ul>\n<ul><li>Must have completed academic and practical competencies&nbsp;required&nbsp;(this includes Line of Progression requirements for internal employees where LOP Exists) and have experience&nbsp;demonstrating&nbsp;the required aptitude. The selected candidate shall&nbsp;demonstrate&nbsp;the ability to apply knowledge and skills while also passing a written assessment where&nbsp;required. This exam is based on skills\/abilities and\/or academic&nbsp;knowledge;&nbsp;as well as safety.&nbsp;&nbsp;<\/li><\/ul>\n<p><strong>Preferred Qualifications<\/strong>&nbsp;<\/p>\n<ul><li>High School diploma or GED&nbsp;&nbsp;<\/li><\/ul>\n<ul><li>Experience with VFDs, PLC, HMI, and\/or SCADA Control Systems&nbsp;&nbsp;<\/li><\/ul>\n<ul><li>Experience working with low and medium voltages&nbsp;&nbsp;<\/li><\/ul>\n<ul><li>Experience with AC and\/or DC controls&nbsp;&nbsp;<\/li><\/ul>\n<ul><li>Experience with instrumentation devices&nbsp;&nbsp;<\/li><\/ul>\n<ul><li>Experience with diagnostic electrical test equipment&nbsp;&nbsp;<\/li><\/ul>\n<ul><li>Experience with HVAC equipment&nbsp;&nbsp;<br>&nbsp;&nbsp;<\/li><\/ul>\n<p><strong>What We Offer You&nbsp;<\/strong>&nbsp;<\/p>\n<p>The estimated pay range for this role is currently\u202f<strong>$32.00 - $44.00\/hour.<\/strong>&nbsp;This range reflects base salary only and does not include bonus payments,&nbsp;benefits&nbsp;or retirement contributions. Actual base pay is&nbsp;determined&nbsp;by experience, qualifications,&nbsp;skills&nbsp;and other job-related factors. &nbsp;This role is eligible for&nbsp;additional&nbsp;discretionary and incentive payment considerations based on company and individual performance. More details will be shared during the hiring process.&nbsp;<\/p>\n<ul><li>$50 per-shift stipend available to employees assigned to specific positions, within the Smelter Electrical and E\/I Maintenance departments, which meet program guidelines.&nbsp;<\/li><\/ul>\n<ul><li>Affordable medical, dental and vision benefits\u202f&nbsp;&nbsp;<\/li><\/ul>\n<ul><li>Company-paid life and disability insurance\u202f&nbsp;&nbsp;<\/li><\/ul>\n<ul><li>401(k) plan with employer contribution\/match\u202f&nbsp;&nbsp;<\/li><\/ul>\n<ul><li>Paid time off, paid sick time, holiday pay, parental leave\u202f&nbsp;&nbsp;<\/li><\/ul>\n<ul><li>Tuition&nbsp;assistance\u202f&nbsp;&nbsp;<\/li><\/ul>\n<ul><li>Employee Assistance Program\u202f&nbsp;&nbsp;<\/li><\/ul>\n<ul><li>Discounted insurance plans for pet, auto,&nbsp;home&nbsp;and vehicle\u202f&nbsp;&nbsp;<\/li><\/ul>\n<ul><li>Internal progression opportunities\u202f&nbsp;&nbsp;<\/li><\/ul>\n<ul><li><a href=\"https:\/\/jobs.fcx.com\/content\/Benefits\/?locale=en_US\" target=\"_blank\" rel=\"noreferrer noopener\" data-faitracker-click-bind=\"true\">Learn more<\/a>&nbsp;about our competitive and comprehensive benefits package!\u202f&nbsp;&nbsp;<\/li><\/ul>\n<p><strong>\u202fWhat We Require\u202f\u202f&nbsp;<\/strong>&nbsp;<\/p>\n<ul><li>Candidates may&nbsp;be required&nbsp;to pass a medical exam.\u202f&nbsp;&nbsp;<\/li><\/ul>\n<ul><li>Candidates must pass all required training and\/or testing.\u202f&nbsp;&nbsp;<\/li><\/ul>\n<ul><li>Employees may&nbsp;be required&nbsp;to&nbsp;work&nbsp;a non-standard schedule, which may include shift work (other than day shift) at a 24\/7, 365-day operation.\u202f&nbsp;&nbsp;<\/li><\/ul>\n<ul><li>We&nbsp;promote&nbsp;a drug\/alcohol-free work environment using mandatory pre-employment drug testing and on-going drug and alcohol testing, as allowed by applicable laws.\u202f&nbsp;&nbsp;<\/li><\/ul>\n<p><strong>&nbsp;Equal Opportunity Employer\u202f<\/strong>&nbsp;<\/p>","post_title":"Diagnostic Electrician &#8211; Smelter","post_link":"https:\/\/turnerstaffing.com\/position\/diagnostic-electrician-smelter\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"","%location_country%":"United States","%location_city%":"Miami","%location_state_id%":"AZ","%location_state_name%":"Arizona","%location_city_state%":"Miami, AZ","%education%":"","%department%":"","%description%":"<p><strong>Where You Will Work\u202f\u202f&nbsp;<\/strong>&nbsp;<\/p>\n<p>Our Miami smelter and rod plant is nestled just 90 miles east of Phoenix. The smelter processes copper concentrate primarily from our company\u2019s Arizona copper mines and is the most significant source of sulfuric acid for our North American leaching operations. Arizona\u2019s Globe-Miami\u202fhistoric mining district offers natural beauty and a rich mining heritage.&nbsp;&nbsp;<\/p>\n<p><strong>What You Will Do<\/strong>&nbsp;<\/p>\n<ul><li>Removal, repair and installation of electrical components, electrical systems, analysis and diagnosis, advanced&nbsp;troubleshooting&nbsp;and systems\/process optimization; may mentor or train other electrical workers&nbsp;<\/li><\/ul>\n<ul><li>Safe completion of routine and non-routine repairs and construction&nbsp;<\/li><\/ul>\n<ul><li>Perform preventative maintenance including installation, repair and troubleshooting of&nbsp;industrical&nbsp;electrical and\/or instrumentation equipment (i.e.&nbsp;substations, power distribution systems, switchgear motors, motor controls, systems and components, process controls,&nbsp;instrumentation&nbsp;and pneumatic equipment)&nbsp;<\/li><\/ul>\n<ul><li>Must have strong knowledge in the maintenance and troubleshooting of AC\/DC drives, PLCs, overhead cranes, management control systems, calibration of field transmitters\/transducers and weigh scales, and low and medium voltage equipment&nbsp;<\/li><\/ul>\n<ul><li>Ability to perform installations and renovations compliant with regulatory agency standards&nbsp;<\/li><\/ul>\n<ul><li>Follow Standard Operating&nbsp;Procedues&nbsp;(SOP) and work area instructions,&nbsp;participate&nbsp;in safety and environmental activities, and&nbsp;use plant and equipment correctly at all times&nbsp;<\/li><\/ul>\n<p><strong>What You Bring&nbsp;<\/strong>&nbsp;<\/p>\n<ul><li>Completion of an approved Certified Electronics, Electrical and\/or Instrumentation Program,\u202f<strong>OR&nbsp;<\/strong>&nbsp;<\/li><\/ul>\n<ul><li>Minimum of four (4) years of experience in Industrial Electrical and\/or Instrumentation repair and maintenance,\u202f<strong>OR&nbsp;<\/strong>&nbsp;<\/li><\/ul>\n<ul><li>Associate's degree or Trade School Certification in a related field\u202f<strong>and\u202f<\/strong>two (2) years of experience in Industrial Electrical and\/or Instrumentation repair and maintenance&nbsp;&nbsp;<\/li><\/ul>\n<ul><li>Experience in troubleshooting, maintenance and repair of electrical circuits and connected equipment; this includes the ability to read, understand and apply information from technical manuals, prints, and schematics for trouble shooting and repair&nbsp;&nbsp;<\/li><\/ul>\n<ul><li>Effective written and verbal communication skills to satisfy training, safety, and electronic message transmission policies of the company&nbsp;&nbsp;<\/li><\/ul>\n<ul><li>Must have&nbsp;minimum&nbsp;personal tools as described by the department tool list or be able to obtain them within&nbsp;90 days&nbsp;of hire date&nbsp;&nbsp;<\/li><\/ul>\n<ul><li>Must have completed academic and practical competencies&nbsp;required&nbsp;(this includes Line of Progression requirements for internal employees where LOP Exists) and have experience&nbsp;demonstrating&nbsp;the required aptitude. The selected candidate shall&nbsp;demonstrate&nbsp;the ability to apply knowledge and skills while also passing a written assessment where&nbsp;required. This exam is based on skills\/abilities and\/or academic&nbsp;knowledge;&nbsp;as well as safety.&nbsp;&nbsp;<\/li><\/ul>\n<p><strong>Preferred Qualifications<\/strong>&nbsp;<\/p>\n<ul><li>High School diploma or GED&nbsp;&nbsp;<\/li><\/ul>\n<ul><li>Experience with VFDs, PLC, HMI, and\/or SCADA Control Systems&nbsp;&nbsp;<\/li><\/ul>\n<ul><li>Experience working with low and medium voltages&nbsp;&nbsp;<\/li><\/ul>\n<ul><li>Experience with AC and\/or DC controls&nbsp;&nbsp;<\/li><\/ul>\n<ul><li>Experience with instrumentation devices&nbsp;&nbsp;<\/li><\/ul>\n<ul><li>Experience with diagnostic electrical test equipment&nbsp;&nbsp;<\/li><\/ul>\n<ul><li>Experience with HVAC equipment&nbsp;&nbsp;<br>&nbsp;&nbsp;<\/li><\/ul>\n<p><strong>What We Offer You&nbsp;<\/strong>&nbsp;<\/p>\n<p>The estimated pay range for this role is currently\u202f<strong>$32.00 - $44.00\/hour.<\/strong>&nbsp;This range reflects base salary only and does not include bonus payments,&nbsp;benefits&nbsp;or retirement contributions. Actual base pay is&nbsp;determined&nbsp;by experience, qualifications,&nbsp;skills&nbsp;and other job-related factors. &nbsp;This role is eligible for&nbsp;additional&nbsp;discretionary and incentive payment considerations based on company and individual performance. More details will be shared during the hiring process.&nbsp;<\/p>\n<ul><li>$50 per-shift stipend available to employees assigned to specific positions, within the Smelter Electrical and E\/I Maintenance departments, which meet program guidelines.&nbsp;<\/li><\/ul>\n<ul><li>Affordable medical, dental and vision benefits\u202f&nbsp;&nbsp;<\/li><\/ul>\n<ul><li>Company-paid life and disability insurance\u202f&nbsp;&nbsp;<\/li><\/ul>\n<ul><li>401(k) plan with employer contribution\/match\u202f&nbsp;&nbsp;<\/li><\/ul>\n<ul><li>Paid time off, paid sick time, holiday pay, parental leave\u202f&nbsp;&nbsp;<\/li><\/ul>\n<ul><li>Tuition&nbsp;assistance\u202f&nbsp;&nbsp;<\/li><\/ul>\n<ul><li>Employee Assistance Program\u202f&nbsp;&nbsp;<\/li><\/ul>\n<ul><li>Discounted insurance plans for pet, auto,&nbsp;home&nbsp;and vehicle\u202f&nbsp;&nbsp;<\/li><\/ul>\n<ul><li>Internal progression opportunities\u202f&nbsp;&nbsp;<\/li><\/ul>\n<ul><li><a href=\"https:\/\/jobs.fcx.com\/content\/Benefits\/?locale=en_US\" target=\"_blank\" rel=\"noreferrer noopener\" data-faitracker-click-bind=\"true\">Learn more<\/a>&nbsp;about our competitive and comprehensive benefits package!\u202f&nbsp;&nbsp;<\/li><\/ul>\n<p><strong>\u202fWhat We Require\u202f\u202f&nbsp;<\/strong>&nbsp;<\/p>\n<ul><li>Candidates may&nbsp;be required&nbsp;to pass a medical exam.\u202f&nbsp;&nbsp;<\/li><\/ul>\n<ul><li>Candidates must pass all required training and\/or testing.\u202f&nbsp;&nbsp;<\/li><\/ul>\n<ul><li>Employees may&nbsp;be required&nbsp;to&nbsp;work&nbsp;a non-standard schedule, which may include shift work (other than day shift) at a 24\/7, 365-day operation.\u202f&nbsp;&nbsp;<\/li><\/ul>\n<ul><li>We&nbsp;promote&nbsp;a drug\/alcohol-free work environment using mandatory pre-employment drug testing and on-going drug and alcohol testing, as allowed by applicable laws.\u202f&nbsp;&nbsp;<\/li><\/ul>\n<p><strong>&nbsp;Equal Opportunity Employer\u202f<\/strong>&nbsp;<\/p>","%category%":"","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/5a2dd1379516-diagnostic-electrician-smelter","%breezy_id%":"5a2dd1379516","%breezy_friendly_id%":"5a2dd1379516-diagnostic-electrician-smelter","%breezy_created_date%":"2026-02-04T17:22:01.798Z","%breezy_updated_date%":"2026-02-04T17:23:59.385Z","%_wpgmp_location_city%":"Miami","%_wpgmp_location_state%":"AZ","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Miami, AZ, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"33.3992217","%_wpgmp_metabox_longitude%":"-110.8687232","%rank_math_internal_links_processed%":"1"}},"id":3124,"infowindow_disable":false},{"source":"post","title":"Senior UX Designer","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Senior UX Designer\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Job Description: Senior User Experience (UX) Designer User Experience Designers balance business goals and user needs to create public-facing digital&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/senior-ux-designer\/\" name=\"Senior UX Designer\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Job Description: Senior User Experience (UX) Designer User Experience Designers balance business goals and user needs to create public-facing digital&hellip;","address":"Tempe, AZ, USA","location":{"lat":"33.4255104","city":"Tempe","state":"AZ","country":"United States","lng":"-111.9400054","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/senior-ux-designer\/","zoom":19,"extra_fields":{"post_excerpt":"Job Description: Senior User Experience (UX) Designer User Experience Designers balance business goals and user needs to create public-facing digital&hellip;","post_content":"<p><strong>Job Description: Senior User Experience (UX) Designer <\/strong>  <\/p>\n<p>User Experience Designers balance business goals and user needs to create public-facing digital experiences that are easy to use, accessible and results-oriented. They have a strong understanding of the principles of UX design, usability and accessibility best practices. They are well-versed in wireframing, prototyping, form design and have a functional understanding of coding and digital content strategy. UX designers work alongside UX researchers, the creative team and web developers to create and iterate on web experiences that enhance customer experience with our brand across numerous digital properties. As members of the web team, UX Designers also support content publishing and operation of websites.   <\/p>\n<p><strong>Job Responsibilities <\/strong>  <\/p>\n<ul>\n <li>Manage      the information architecture of our websites and enhance user experience      by creating seamless journeys through various digital      properties.    <\/li>\n <li>Lead      core content modeling sessions to set the structure and content      strategy for web content, collaborating with content      strategists, copywriters and visual designers.   <\/li>\n <li>Build      wireframes and mid\/high fidelity, interactive prototypes, collaborating      with visual designers and web developers to turn them into digital      experiences that meet the needs of both the brand and our      customers.   <\/li>\n <li>Work      with UX researchers to complete and analyze research      studies.    <\/li>\n <li>Collaborate      with business analysts as they complete technical specifications      and maintain documentation.   <\/li>\n <li>Design      forms \u2013 from simple to complex \u2013 to ensure ease of use for customers and      other stakeholder groups.   <\/li>\n <li>Stay up      to date on recent studies and research findings      to establish the best overall UX design elements to include in      digital experiences.   <\/li>\n <li>Lead      web governance and make continued accessibility and UX      improvements.   <\/li>\n <li>Create,      maintain and update web content in a content management system. <\/li>\n <li>Understand web      analytics, website performance, and A\/B testing outcomes is a plus. <\/li>\n<\/ul>\n<p><strong>Education and\/or Experience:<\/strong> <\/p>\n<ul>\n <li>Minimum      of 5\u202fyears of      experience in UX design in a professional setting. <\/li>\n <li>Bachelor\u2019s      Degree preferred, but all relevant job experience will be taken into      consideration. <\/li>\n<\/ul>\n<p><strong>Additional Information <\/strong>  <\/p>\n<ul>\n <li>Professional      portfolio with design samples required. <\/li>\n <li>Proficient with visual      design and prototyping programs such as Figma and Adobe XD.  <\/li>\n <li>Strong      time management, organizational, and project management skills to      handle high volume of work of high complexity on time and within budget      allotted.  <\/li>\n <li>Microsoft      Workfront experience is a plus.  <\/li>\n <li>Basic      experience with HTML and CSS and how backend and frontend      technologies work together.  <\/li>\n <li>Comfort      working in component-based content management systems.  <\/li>\n <li>Understanding      of digital content strategy.  <\/li>\n <li>Ability      to work effectively in a collaborative environment to create      top-performing interfaces for customers.  <\/li>\n <li>Ability      to communicate clearly and lead presentations on user experience      decisions.  <\/li>\n <li>Knowledge      of UX trends and current design strategy and technologies.       <\/li>\n<\/ul>","post_title":"Senior UX Designer","post_link":"https:\/\/turnerstaffing.com\/position\/senior-ux-designer\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Mid Level","%location_country%":"United States","%location_city%":"Tempe","%location_state_id%":"AZ","%location_state_name%":"Arizona","%location_city_state%":"Tempe, AZ","%education%":"Bachelor's Degree","%department%":"","%description%":"<p><strong>Job Description: Senior User Experience (UX) Designer <\/strong>  <\/p>\n<p>User Experience Designers balance business goals and user needs to create public-facing digital experiences that are easy to use, accessible and results-oriented. They have a strong understanding of the principles of UX design, usability and accessibility best practices. They are well-versed in wireframing, prototyping, form design and have a functional understanding of coding and digital content strategy. UX designers work alongside UX researchers, the creative team and web developers to create and iterate on web experiences that enhance customer experience with our brand across numerous digital properties. As members of the web team, UX Designers also support content publishing and operation of websites.   <\/p>\n<p><strong>Job Responsibilities <\/strong>  <\/p>\n<ul>\n <li>Manage      the information architecture of our websites and enhance user experience      by creating seamless journeys through various digital      properties.    <\/li>\n <li>Lead      core content modeling sessions to set the structure and content      strategy for web content, collaborating with content      strategists, copywriters and visual designers.   <\/li>\n <li>Build      wireframes and mid\/high fidelity, interactive prototypes, collaborating      with visual designers and web developers to turn them into digital      experiences that meet the needs of both the brand and our      customers.   <\/li>\n <li>Work      with UX researchers to complete and analyze research      studies.    <\/li>\n <li>Collaborate      with business analysts as they complete technical specifications      and maintain documentation.   <\/li>\n <li>Design      forms \u2013 from simple to complex \u2013 to ensure ease of use for customers and      other stakeholder groups.   <\/li>\n <li>Stay up      to date on recent studies and research findings      to establish the best overall UX design elements to include in      digital experiences.   <\/li>\n <li>Lead      web governance and make continued accessibility and UX      improvements.   <\/li>\n <li>Create,      maintain and update web content in a content management system. <\/li>\n <li>Understand web      analytics, website performance, and A\/B testing outcomes is a plus. <\/li>\n<\/ul>\n<p><strong>Education and\/or Experience:<\/strong> <\/p>\n<ul>\n <li>Minimum      of 5\u202fyears of      experience in UX design in a professional setting. <\/li>\n <li>Bachelor\u2019s      Degree preferred, but all relevant job experience will be taken into      consideration. <\/li>\n<\/ul>\n<p><strong>Additional Information <\/strong>  <\/p>\n<ul>\n <li>Professional      portfolio with design samples required. <\/li>\n <li>Proficient with visual      design and prototyping programs such as Figma and Adobe XD.  <\/li>\n <li>Strong      time management, organizational, and project management skills to      handle high volume of work of high complexity on time and within budget      allotted.  <\/li>\n <li>Microsoft      Workfront experience is a plus.  <\/li>\n <li>Basic      experience with HTML and CSS and how backend and frontend      technologies work together.  <\/li>\n <li>Comfort      working in component-based content management systems.  <\/li>\n <li>Understanding      of digital content strategy.  <\/li>\n <li>Ability      to work effectively in a collaborative environment to create      top-performing interfaces for customers.  <\/li>\n <li>Ability      to communicate clearly and lead presentations on user experience      decisions.  <\/li>\n <li>Knowledge      of UX trends and current design strategy and technologies.       <\/li>\n<\/ul>","%category%":"Design","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/83cb05b0a069-senior-ux-designer","%breezy_id%":"83cb05b0a069","%breezy_friendly_id%":"83cb05b0a069-senior-ux-designer","%breezy_created_date%":"2026-02-04T19:35:00.921Z","%breezy_updated_date%":"2026-02-04T20:02:30.063Z","%_wpgmp_location_city%":"Tempe","%_wpgmp_location_state%":"AZ","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Tempe, AZ, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"33.4255104","%_wpgmp_metabox_longitude%":"-111.9400054","%rank_math_internal_links_processed%":"1"}},"id":3125,"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    POSITION SUMMARY This position uses established procedures to collect and interpret geological observations and samples for the purpose of guiding&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":"POSITION SUMMARY This position uses established procedures to collect and interpret geological observations and samples for the purpose of guiding&hellip;","address":"Juneau, AK, USA","location":{"lat":"58.3004933","city":"Juneau","state":"AK","country":"United States","lng":"-134.4201306","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/geologist-4\/","zoom":19,"extra_fields":{"post_excerpt":"POSITION SUMMARY This position uses established procedures to collect and interpret geological observations and samples for the purpose of guiding&hellip;","post_content":"<p><strong>POSITION SUMMARY <\/strong><\/p><p>This position uses established procedures to collect and interpret geological observations and samples for the purpose of guiding the mining effort. The role is based within an underground mine and is critical to the successful mining of this structurally complicated deposit. Production geologists are mobile, driving their own vehicle and utilizing a lift vehicle for sampling the face. The majority of an average workday occurs underground, collecting observations and samples, lining out headings, and involves clear and consistent communication with the operations and engineering groups.<\/p><p>&nbsp;<\/p><p><strong>ESSENTIAL FUNCTIONS &ndash; Other Duties May be Assigned <\/strong><\/p><p>Within this role, technical functions are executed at an advanced level of capability with little to no involvement from a supervisor. Technical functions for the role may include: <\/p><p>&bull; Map and sample ore faces for assaying <\/p><p>&bull; Identify potential geologic hazards and understand bolting requirements <\/p><p>&bull; Provide stope scale (or smaller) structural understanding to predict geologic hazards in front of current face <\/p><p>&bull; Map ribs of completed stopes to identify slabs, benches or extra panels <\/p><p>&bull; Make muck pile calls for placement according to acid generation characteristics <\/p><p>&bull; Sample ribs for acid-rock characterization <\/p><p>&bull; Enter face mapping and sampling into AutoCAD and acQuire <\/p><p>&bull; Prepare mine production reports and distribute on a daily basis <\/p><p>&bull; Participate in map meetings by providing relevant geologic information <\/p><p>&bull; Prepare ARD (acid generating potential) reports from underground rib sampling <\/p><p>&bull; Able to adjust varying points of reference while safely navigating the terrain, maintaining awareness of traffic, and operating tools and machinery <\/p><p>&bull; Able to identify vehicles, machinery, and people in peripheral vision <\/p><p><strong>Speaking: <\/strong><\/p><p>&bull; Able to clearly communicate with co-workers and supervisors on the radio and in person <\/p><p><strong>Hearing: <\/strong><\/p><p>&bull; Must wear hearing protection while working in loud environments <\/p><p>&nbsp;<\/p><p><strong>QUALIFICATIONS<\/strong><\/p><p><strong>Education and\/or Experience<\/strong><\/p><p>&bull; BS in geological engineering or geology from a four-year college or university <\/p><p>&bull; One year or more experience in exploration or mining geology, <strong>preferably underground<\/strong>. <\/p><p><strong>Other Qualifications <\/strong><\/p><p>&bull; Proficient with Microsoft and AutoCAD software. <\/p><p>&bull; Preferred: Knowledge of Datamine, LeapFrog, or equivalent modeling software helpful. <\/p><p>&bull; Familiar with various mining methods.<\/p><p>&bull; Must be authorized to work in the US for any employer,<\/p><p>&nbsp;<\/p><p><strong>PHYSICAL DEMANDS <\/strong><\/p><p>While performing the duties of this job, employees may be frequently required to stand, walk or sit for extended periods of time; use hand and fingers to handle or feel; reach with hands and arms; climb or balance; stoop, kneel, crouch, or crawl; regularly required to talk and hear. The employee must regularly lift and\/or move up to 50 pounds and occasionally lift and\/or move up to 75 pounds. Specific vision requirements for this job include close vision, distance vision, and the ability to adjust focus.<\/p><p>&nbsp;<\/p><p>This position may occasionally require work on nights. The position follows a 14 days on 14 days off rotation.<\/p><p>&nbsp;<\/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%":"Juneau","%location_state_id%":"AK","%location_city_state%":"Juneau, AK","%description%":"<p><strong>POSITION SUMMARY <\/strong><\/p><p>This position uses established procedures to collect and interpret geological observations and samples for the purpose of guiding the mining effort. The role is based within an underground mine and is critical to the successful mining of this structurally complicated deposit. Production geologists are mobile, driving their own vehicle and utilizing a lift vehicle for sampling the face. The majority of an average workday occurs underground, collecting observations and samples, lining out headings, and involves clear and consistent communication with the operations and engineering groups.<\/p><p>&nbsp;<\/p><p><strong>ESSENTIAL FUNCTIONS &ndash; Other Duties May be Assigned <\/strong><\/p><p>Within this role, technical functions are executed at an advanced level of capability with little to no involvement from a supervisor. Technical functions for the role may include: <\/p><p>&bull; Map and sample ore faces for assaying <\/p><p>&bull; Identify potential geologic hazards and understand bolting requirements <\/p><p>&bull; Provide stope scale (or smaller) structural understanding to predict geologic hazards in front of current face <\/p><p>&bull; Map ribs of completed stopes to identify slabs, benches or extra panels <\/p><p>&bull; Make muck pile calls for placement according to acid generation characteristics <\/p><p>&bull; Sample ribs for acid-rock characterization <\/p><p>&bull; Enter face mapping and sampling into AutoCAD and acQuire <\/p><p>&bull; Prepare mine production reports and distribute on a daily basis <\/p><p>&bull; Participate in map meetings by providing relevant geologic information <\/p><p>&bull; Prepare ARD (acid generating potential) reports from underground rib sampling <\/p><p>&bull; Able to adjust varying points of reference while safely navigating the terrain, maintaining awareness of traffic, and operating tools and machinery <\/p><p>&bull; Able to identify vehicles, machinery, and people in peripheral vision <\/p><p><strong>Speaking: <\/strong><\/p><p>&bull; Able to clearly communicate with co-workers and supervisors on the radio and in person <\/p><p><strong>Hearing: <\/strong><\/p><p>&bull; Must wear hearing protection while working in loud environments <\/p><p>&nbsp;<\/p><p><strong>QUALIFICATIONS<\/strong><\/p><p><strong>Education and\/or Experience<\/strong><\/p><p>&bull; BS in geological engineering or geology from a four-year college or university <\/p><p>&bull; One year or more experience in exploration or mining geology, <strong>preferably underground<\/strong>. <\/p><p><strong>Other Qualifications <\/strong><\/p><p>&bull; Proficient with Microsoft and AutoCAD software. <\/p><p>&bull; Preferred: Knowledge of Datamine, LeapFrog, or equivalent modeling software helpful. <\/p><p>&bull; Familiar with various mining methods.<\/p><p>&bull; Must be authorized to work in the US for any employer,<\/p><p>&nbsp;<\/p><p><strong>PHYSICAL DEMANDS <\/strong><\/p><p>While performing the duties of this job, employees may be frequently required to stand, walk or sit for extended periods of time; use hand and fingers to handle or feel; reach with hands and arms; climb or balance; stoop, kneel, crouch, or crawl; regularly required to talk and hear. The employee must regularly lift and\/or move up to 50 pounds and occasionally lift and\/or move up to 75 pounds. Specific vision requirements for this job include close vision, distance vision, and the ability to adjust focus.<\/p><p>&nbsp;<\/p><p>This position may occasionally require work on nights. The position follows a 14 days on 14 days off rotation.<\/p><p>&nbsp;<\/p>","%application_url%":"https:\/\/jobs.crelate.com\/portal\/turnerstaffinggroup\/job\/qb5urgoj9ujf8kz5jb8hq59fxe","%crelate_id%":"qb5urgoj9ujf8kz5jb8hq59fxe","%crelate_created_date%":"2026-02-03T11:28:11.94Z","%crelate_updated_date%":"2026-02-04T13:42:24.97Z","%_wpgmp_location_city%":"Juneau","%_wpgmp_location_state%":"AK","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Juneau, AK, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"58.3004933","%_wpgmp_metabox_longitude%":"-134.4201306","%rank_math_internal_links_processed%":"1"}},"id":3122,"infowindow_disable":false},{"source":"post","title":"Project Manager","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Project Manager\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Project Manager \u2014 Dallas, TX Our client is seeking a Project Manager to oversee the planning, coordination, and execution of&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/project-manager\/\" name=\"Project Manager\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Project Manager \u2014 Dallas, TX Our client is seeking a Project Manager to oversee the planning, coordination, and execution of&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\/project-manager\/","zoom":19,"extra_fields":{"post_excerpt":"Project Manager \u2014 Dallas, TX Our client is seeking a Project Manager to oversee the planning, coordination, and execution of&hellip;","post_content":"<h1><strong>Project Manager \u2014 Dallas, TX<\/strong><\/h1>\n<p>Our client is seeking a <strong>Project Manager<\/strong> to oversee the planning, coordination, and execution of large technical projects. This role manages schedules, budgets, customer communication, and cross\u2011functional alignment to ensure successful project delivery from design through closeout.<\/p>\n<h2><strong>Key Responsibilities<\/strong><\/h2>\n<ul>\n<li>Serve as primary customer contact and support contract, schedule, and change\u2011order discussions.<\/li>\n<li>Translate customer requirements into project plans and coordinate technical deliverables with engineering teams.<\/li>\n<li>Develop and manage project schedules, milestones, and resource needs.<\/li>\n<li>Monitor progress, identify risks, and drive corrective actions.<\/li>\n<li>Track budgets, spending, and financial performance throughout the project.<\/li>\n<li>Ensure all deliverables meet engineering, quality, and regulatory standards.<\/li>\n<li>Coordinate with internal teams (engineering, production, procurement, quality) to ensure alignment.<\/li>\n<li>Maintain accurate documentation for reviews, audits, and project closeout.<\/li>\n<\/ul>\n<h2><strong>Qualifications<\/strong><\/h2>\n<p><strong>Required<\/strong><\/p>\n<ul>\n<li>Bachelor\u2019s degree in Engineering or equivalent technical background.<\/li>\n<li>4\u20136 years of project management experience in an engineering\u2011focused environment.<\/li>\n<li>Experience managing customer\u2011facing, multi\u2011phase projects.<\/li>\n<li>Knowledge of engineering principles and technical documentation.<\/li>\n<li>Strong communication, organization, and problem\u2011solving skills.<\/li>\n<li>Proficiency with project management software and ERP systems.<\/li>\n<\/ul>\n<p><strong>Preferred<\/strong><\/p>\n<ul>\n<li>PMP certification.<\/li>\n<li>Experience with large\u2011scale or high\u2011budget projects.<\/li>\n<li>Familiarity with lean manufacturing, quality systems, or regulated industries.<\/li>\n<\/ul>\n<h2><b>This is an in-office role based in Dallas, TX.<\/b><\/h2>","post_title":"Project Manager","post_link":"https:\/\/turnerstaffing.com\/position\/project-manager\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Associate","%location_country%":"United States","%location_city%":"Dallas","%location_state_id%":"TX","%location_state_name%":"Texas","%location_city_state%":"Dallas, TX","%education%":"Bachelor's Degree","%department%":"","%description%":"<h1><strong>Project Manager \u2014 Dallas, TX<\/strong><\/h1>\n<p>Our client is seeking a <strong>Project Manager<\/strong> to oversee the planning, coordination, and execution of large technical projects. This role manages schedules, budgets, customer communication, and cross\u2011functional alignment to ensure successful project delivery from design through closeout.<\/p>\n<h2><strong>Key Responsibilities<\/strong><\/h2>\n<ul>\n<li>Serve as primary customer contact and support contract, schedule, and change\u2011order discussions.<\/li>\n<li>Translate customer requirements into project plans and coordinate technical deliverables with engineering teams.<\/li>\n<li>Develop and manage project schedules, milestones, and resource needs.<\/li>\n<li>Monitor progress, identify risks, and drive corrective actions.<\/li>\n<li>Track budgets, spending, and financial performance throughout the project.<\/li>\n<li>Ensure all deliverables meet engineering, quality, and regulatory standards.<\/li>\n<li>Coordinate with internal teams (engineering, production, procurement, quality) to ensure alignment.<\/li>\n<li>Maintain accurate documentation for reviews, audits, and project closeout.<\/li>\n<\/ul>\n<h2><strong>Qualifications<\/strong><\/h2>\n<p><strong>Required<\/strong><\/p>\n<ul>\n<li>Bachelor\u2019s degree in Engineering or equivalent technical background.<\/li>\n<li>4\u20136 years of project management experience in an engineering\u2011focused environment.<\/li>\n<li>Experience managing customer\u2011facing, multi\u2011phase projects.<\/li>\n<li>Knowledge of engineering principles and technical documentation.<\/li>\n<li>Strong communication, organization, and problem\u2011solving skills.<\/li>\n<li>Proficiency with project management software and ERP systems.<\/li>\n<\/ul>\n<p><strong>Preferred<\/strong><\/p>\n<ul>\n<li>PMP certification.<\/li>\n<li>Experience with large\u2011scale or high\u2011budget projects.<\/li>\n<li>Familiarity with lean manufacturing, quality systems, or regulated industries.<\/li>\n<\/ul>\n<h2><b>This is an in-office role based in Dallas, TX.<\/b><\/h2>","%category%":"Other","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/1cab9a0fa2f0-project-manager","%breezy_id%":"1cab9a0fa2f0","%breezy_friendly_id%":"1cab9a0fa2f0-project-manager","%breezy_created_date%":"2026-02-02T20:48:21.527Z","%breezy_updated_date%":"2026-02-02T20:50:20.141Z","%_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":3120,"infowindow_disable":false},{"source":"post","title":"Civil\/Structural Design Supervisor","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Civil\/Structural Design Supervisor\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Where You Will Work This role is based in the Lower Garden District of New Orleans, Louisiana. Employees assigned to&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/civil-structural-design-supervisor\/\" name=\"Civil\/Structural Design Supervisor\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Where You Will Work This role is based in the Lower Garden District of New Orleans, Louisiana. Employees assigned to&hellip;","address":"New Orleans, LA, USA","location":{"lat":"29.9508941","city":"New Orleans","state":"LA","country":"United States","lng":"-90.0758356","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/civil-structural-design-supervisor\/","zoom":19,"extra_fields":{"post_excerpt":"Where You Will Work This role is based in the Lower Garden District of New Orleans, Louisiana. Employees assigned to&hellip;","post_content":"<h2>Where You Will Work<\/h2>\n<p>This role is based in the <strong>Lower Garden District of New Orleans, Louisiana<\/strong>. Employees assigned to this position generally follow a <strong>hybrid work schedule<\/strong>, which includes working in the office for in-person meetings, collaboration, and training, along with opportunities for virtual collaboration.<\/p>\n<p>New Orleans is a vibrant city known for its historic architecture, cultural arts, live music, and world-class cuisine. The office is within walking distance of numerous hotels, restaurants, galleries, and museums, offering a dynamic and engaging work environment.<\/p>\n<h2>What You Will Do<\/h2>\n<p>The <strong>Senior Engineering Specialist \u2013 Civil\/Structural Design<\/strong>, placed through <strong>Turner Staffing Group<\/strong>, plays a key role in guiding the strategic direction of engineering projects from concept through execution. This position establishes and implements CAD best practices, leads design teams, and promotes a culture of innovation, quality, and efficiency throughout the project lifecycle.<\/p>\n<p>Key responsibilities include:<\/p>\n<ul>\n<li>\n<p>Leading, managing, training, and mentoring a team of civil\/structural designers<\/p>\n<\/li>\n<li>\n<p>Establishing design objectives and technical specifications aligned with project goals<\/p>\n<\/li>\n<li>\n<p>Ensuring quality, consistency, and compliance across all design deliverables<\/p>\n<\/li>\n<li>\n<p>Coordinating and leading design reviews and project CAD setup activities<\/p>\n<\/li>\n<li>\n<p>Developing, documenting, and implementing CAD standards and best practices<\/p>\n<\/li>\n<li>\n<p>Coordinating design resource allocation with engineering leadership<\/p>\n<\/li>\n<li>\n<p>Evaluating design personnel skillsets prior to project mobilization<\/p>\n<\/li>\n<li>\n<p>Collaborating with multi-discipline teams to develop procedural interfaces<\/p>\n<\/li>\n<li>\n<p>Working with software vendors to resolve technical and application issues<\/p>\n<\/li>\n<li>\n<p>Managing project schedules and budgets related to design execution<\/p>\n<\/li>\n<li>\n<p>Educating engineering personnel on CAD software functionality and workflows<\/p>\n<\/li>\n<li>\n<p>Ensuring compliance with applicable industry standards and safety regulations<\/p>\n<\/li>\n<li>\n<p>Performing additional duties as required<\/p>\n<\/li>\n<\/ul>\n<h2>What You Bring<\/h2>\n<ul>\n<li>\n<p>High school diploma or GED <strong>and<\/strong> nine (9) years of related engineering design experience, including leadership of design professionals, process development, and execution, <strong>OR<\/strong><\/p>\n<\/li>\n<li>\n<p>Bachelor\u2019s degree in a related scientific or engineering discipline <strong>and<\/strong> five (5) years of engineering design experience, including leadership of design professionals, process development, and execution<\/p>\n<\/li>\n<\/ul>\n<h2>Preferred Qualifications<\/h2>\n<ul>\n<li>\n<p>Strong proficiency with industry-standard CAD tools<\/p>\n<\/li>\n<li>\n<p>Excellent leadership, communication, and project management skills<\/p>\n<\/li>\n<li>\n<p>Proven ability to manage complex design projects and deliver results on schedule<\/p>\n<\/li>\n<li>\n<p>Working knowledge of applicable industry standards and regulatory requirements<\/p>\n<\/li>\n<li>\n<p>Understanding of efficient plant and facility layout principles<\/p>\n<\/li>\n<li>\n<p>Associate degree in Drafting and Design or a closely related field<\/p><\/li><\/ul>","post_title":"Civil\/Structural Design Supervisor","post_link":"https:\/\/turnerstaffing.com\/position\/civil-structural-design-supervisor\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Senior","%location_country%":"United States","%location_city%":"New Orleans","%location_state_id%":"LA","%location_state_name%":"Louisiana","%location_city_state%":"New Orleans, LA","%education%":"High School or Equivalent","%department%":"","%description%":"<h2>Where You Will Work<\/h2>\n<p>This role is based in the <strong>Lower Garden District of New Orleans, Louisiana<\/strong>. Employees assigned to this position generally follow a <strong>hybrid work schedule<\/strong>, which includes working in the office for in-person meetings, collaboration, and training, along with opportunities for virtual collaboration.<\/p>\n<p>New Orleans is a vibrant city known for its historic architecture, cultural arts, live music, and world-class cuisine. The office is within walking distance of numerous hotels, restaurants, galleries, and museums, offering a dynamic and engaging work environment.<\/p>\n<h2>What You Will Do<\/h2>\n<p>The <strong>Senior Engineering Specialist \u2013 Civil\/Structural Design<\/strong>, placed through <strong>Turner Staffing Group<\/strong>, plays a key role in guiding the strategic direction of engineering projects from concept through execution. This position establishes and implements CAD best practices, leads design teams, and promotes a culture of innovation, quality, and efficiency throughout the project lifecycle.<\/p>\n<p>Key responsibilities include:<\/p>\n<ul>\n<li>\n<p>Leading, managing, training, and mentoring a team of civil\/structural designers<\/p>\n<\/li>\n<li>\n<p>Establishing design objectives and technical specifications aligned with project goals<\/p>\n<\/li>\n<li>\n<p>Ensuring quality, consistency, and compliance across all design deliverables<\/p>\n<\/li>\n<li>\n<p>Coordinating and leading design reviews and project CAD setup activities<\/p>\n<\/li>\n<li>\n<p>Developing, documenting, and implementing CAD standards and best practices<\/p>\n<\/li>\n<li>\n<p>Coordinating design resource allocation with engineering leadership<\/p>\n<\/li>\n<li>\n<p>Evaluating design personnel skillsets prior to project mobilization<\/p>\n<\/li>\n<li>\n<p>Collaborating with multi-discipline teams to develop procedural interfaces<\/p>\n<\/li>\n<li>\n<p>Working with software vendors to resolve technical and application issues<\/p>\n<\/li>\n<li>\n<p>Managing project schedules and budgets related to design execution<\/p>\n<\/li>\n<li>\n<p>Educating engineering personnel on CAD software functionality and workflows<\/p>\n<\/li>\n<li>\n<p>Ensuring compliance with applicable industry standards and safety regulations<\/p>\n<\/li>\n<li>\n<p>Performing additional duties as required<\/p>\n<\/li>\n<\/ul>\n<h2>What You Bring<\/h2>\n<ul>\n<li>\n<p>High school diploma or GED <strong>and<\/strong> nine (9) years of related engineering design experience, including leadership of design professionals, process development, and execution, <strong>OR<\/strong><\/p>\n<\/li>\n<li>\n<p>Bachelor\u2019s degree in a related scientific or engineering discipline <strong>and<\/strong> five (5) years of engineering design experience, including leadership of design professionals, process development, and execution<\/p>\n<\/li>\n<\/ul>\n<h2>Preferred Qualifications<\/h2>\n<ul>\n<li>\n<p>Strong proficiency with industry-standard CAD tools<\/p>\n<\/li>\n<li>\n<p>Excellent leadership, communication, and project management skills<\/p>\n<\/li>\n<li>\n<p>Proven ability to manage complex design projects and deliver results on schedule<\/p>\n<\/li>\n<li>\n<p>Working knowledge of applicable industry standards and regulatory requirements<\/p>\n<\/li>\n<li>\n<p>Understanding of efficient plant and facility layout principles<\/p>\n<\/li>\n<li>\n<p>Associate degree in Drafting and Design or a closely related field<\/p><\/li><\/ul>","%category%":"Design","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/b37d543cf411-civil-structural-design-supervisor","%breezy_id%":"b37d543cf411","%breezy_friendly_id%":"b37d543cf411-civil-structural-design-supervisor","%breezy_created_date%":"2026-02-02T16:41:31.979Z","%breezy_updated_date%":"2026-02-02T16:42:09.350Z","%_wpgmp_location_city%":"New Orleans","%_wpgmp_location_state%":"LA","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"New Orleans, LA, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"29.9508941","%_wpgmp_metabox_longitude%":"-90.0758356","%rank_math_internal_links_processed%":"1"}},"id":3117,"infowindow_disable":false},{"source":"post","title":"Autonomous Mining Systems Coordinator","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Autonomous Mining Systems Coordinator\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Where You Will Work This role is based at a mining operation in Bagdad, Arizona, a small community offering a&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/autonomous-mining-systems-coordinator\/\" name=\"Autonomous Mining Systems Coordinator\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Where You Will Work This role is based at a mining operation in Bagdad, Arizona, a small community offering a&hellip;","address":"Bagdad, AZ, USA","location":{"lat":"34.5722212","city":"Bagdad","state":"AZ","country":"United States","lng":"-113.1784322","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/autonomous-mining-systems-coordinator\/","zoom":19,"extra_fields":{"post_excerpt":"Where You Will Work This role is based at a mining operation in Bagdad, Arizona, a small community offering a&hellip;","post_content":"<h2>Where You Will Work<\/h2>\n<p>This role is based at a mining operation in <strong>Bagdad, Arizona<\/strong>, a small community offering a family-friendly atmosphere and access to local amenities such as an aquatic center, golf course, and fitness center. Housing may be available at a subsidized rate for eligible employees, subject to assignment terms and client guidelines.<\/p>\n<p>Located approximately 100 miles northwest of Phoenix, the Bagdad site is home to a large-scale concentrate leach processing facility and a long-standing solvent extraction\/electrowinning (SX\/EW) operation supporting copper production.<\/p>\n<h2>Position Overview<\/h2>\n<p>The <strong>Autonomous Mining System Coordinator<\/strong>, placed through <strong>Turner Staffing Group<\/strong>, is responsible for implementing and maintaining the mine model for autonomous haulage systems using MineStar Command for Hauling. This role provides operational and technical support to autonomous mining personnel and ensures system integrity, data accuracy, and safe, efficient autonomous operations.<\/p>\n<h2>What You Will Do<\/h2>\n<ul>\n<li>\n<p>Implement and manage the mine model within MineStar Command for Hauling<\/p>\n<\/li>\n<li>\n<p>Support autonomous mining personnel, including controls specialists and pit technicians<\/p>\n<\/li>\n<li>\n<p>Review system operations, monitor performance, and ensure key performance indicators are met<\/p>\n<\/li>\n<li>\n<p>Maintain onboard files and ensure high-quality data integrity<\/p>\n<\/li>\n<li>\n<p>Troubleshoot system, assignment, and communication issues and escalate unresolved issues as needed<\/p>\n<\/li>\n<li>\n<p>Accurately complete documentation, data entry, shift reports, and shift handover notes<\/p>\n<\/li>\n<li>\n<p>Prioritize work activities to meet shift objectives and operational requirements<\/p>\n<\/li>\n<li>\n<p>Communicate changes to plans or decisions promptly to all affected parties<\/p>\n<\/li>\n<li>\n<p>Maintain clear communication with peers, supervisors, contractors, and cross-functional teams<\/p>\n<\/li>\n<li>\n<p>Coordinate activities with internal and external departments, including maintenance and engineering<\/p>\n<\/li>\n<li>\n<p>Comply with all Turner Staffing Group and client site policies, procedures, and regulations<\/p>\n<\/li>\n<li>\n<p>Report autonomous-related incidents promptly and participate in safety meetings, investigations, and safety programs<\/p>\n<\/li>\n<li>\n<p>Perform additional duties as assigned<\/p>\n<\/li>\n<\/ul>\n<h2>Minimum Qualifications<\/h2>\n<ul>\n<li>\n<p>Minimum of <strong>four (4) years<\/strong> of operational experience in a mining environment, including systems management and troubleshooting<\/p>\n<\/li>\n<li>\n<p>Experience working with MineStar, Modular, or similar dispatch and fleet management systems<\/p>\n<\/li>\n<li>\n<p>Strong computer proficiency<\/p>\n<\/li>\n<li>\n<p>Action-oriented with the ability to prioritize tasks and make informed decisions<\/p>\n<\/li>\n<li>\n<p>Strong interpersonal skills, including active listening and customer focus<\/p>\n<\/li>\n<li>\n<p>Ability to manage competing priorities and negotiate outcomes effectively<\/p>\n<\/li>\n<li>\n<p>Ability to understand and follow verbal and written work and safety instructions in English<\/p>\n<\/li>\n<li>\n<p>Ability to communicate effectively in English regarding job assignments, procedures, and safety standards<\/p>\n<\/li>\n<\/ul>\n<h2>Preferred Qualifications<\/h2>\n<ul>\n<li>\n<p>Bachelor\u2019s degree in a technical or mining-related discipline<\/p>\n<\/li>\n<\/ul>\n<h2>Work Environment &amp; Requirements<\/h2>\n<ul>\n<li>\n<p>Required use of personal protective equipment (PPE) in mine, outdoor, plant, or manufacturing environments, including hard hat, safety glasses, hearing protection, safety footwear, and other PPE as required<\/p>\n<\/li>\n<li>\n<p>Ability to comply with Turner Staffing Group and client drug- and alcohol-free workplace policies, including pre-employment and ongoing testing as permitted by applicable laws<\/p><\/li><\/ul>","post_title":"Autonomous Mining Systems Coordinator","post_link":"https:\/\/turnerstaffing.com\/position\/autonomous-mining-systems-coordinator\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Mid Level","%location_country%":"United States","%location_city%":"Bagdad","%location_state_id%":"AZ","%location_state_name%":"Arizona","%location_city_state%":"Bagdad, AZ","%education%":"Bachelor's Degree","%department%":"","%description%":"<h2>Where You Will Work<\/h2>\n<p>This role is based at a mining operation in <strong>Bagdad, Arizona<\/strong>, a small community offering a family-friendly atmosphere and access to local amenities such as an aquatic center, golf course, and fitness center. Housing may be available at a subsidized rate for eligible employees, subject to assignment terms and client guidelines.<\/p>\n<p>Located approximately 100 miles northwest of Phoenix, the Bagdad site is home to a large-scale concentrate leach processing facility and a long-standing solvent extraction\/electrowinning (SX\/EW) operation supporting copper production.<\/p>\n<h2>Position Overview<\/h2>\n<p>The <strong>Autonomous Mining System Coordinator<\/strong>, placed through <strong>Turner Staffing Group<\/strong>, is responsible for implementing and maintaining the mine model for autonomous haulage systems using MineStar Command for Hauling. This role provides operational and technical support to autonomous mining personnel and ensures system integrity, data accuracy, and safe, efficient autonomous operations.<\/p>\n<h2>What You Will Do<\/h2>\n<ul>\n<li>\n<p>Implement and manage the mine model within MineStar Command for Hauling<\/p>\n<\/li>\n<li>\n<p>Support autonomous mining personnel, including controls specialists and pit technicians<\/p>\n<\/li>\n<li>\n<p>Review system operations, monitor performance, and ensure key performance indicators are met<\/p>\n<\/li>\n<li>\n<p>Maintain onboard files and ensure high-quality data integrity<\/p>\n<\/li>\n<li>\n<p>Troubleshoot system, assignment, and communication issues and escalate unresolved issues as needed<\/p>\n<\/li>\n<li>\n<p>Accurately complete documentation, data entry, shift reports, and shift handover notes<\/p>\n<\/li>\n<li>\n<p>Prioritize work activities to meet shift objectives and operational requirements<\/p>\n<\/li>\n<li>\n<p>Communicate changes to plans or decisions promptly to all affected parties<\/p>\n<\/li>\n<li>\n<p>Maintain clear communication with peers, supervisors, contractors, and cross-functional teams<\/p>\n<\/li>\n<li>\n<p>Coordinate activities with internal and external departments, including maintenance and engineering<\/p>\n<\/li>\n<li>\n<p>Comply with all Turner Staffing Group and client site policies, procedures, and regulations<\/p>\n<\/li>\n<li>\n<p>Report autonomous-related incidents promptly and participate in safety meetings, investigations, and safety programs<\/p>\n<\/li>\n<li>\n<p>Perform additional duties as assigned<\/p>\n<\/li>\n<\/ul>\n<h2>Minimum Qualifications<\/h2>\n<ul>\n<li>\n<p>Minimum of <strong>four (4) years<\/strong> of operational experience in a mining environment, including systems management and troubleshooting<\/p>\n<\/li>\n<li>\n<p>Experience working with MineStar, Modular, or similar dispatch and fleet management systems<\/p>\n<\/li>\n<li>\n<p>Strong computer proficiency<\/p>\n<\/li>\n<li>\n<p>Action-oriented with the ability to prioritize tasks and make informed decisions<\/p>\n<\/li>\n<li>\n<p>Strong interpersonal skills, including active listening and customer focus<\/p>\n<\/li>\n<li>\n<p>Ability to manage competing priorities and negotiate outcomes effectively<\/p>\n<\/li>\n<li>\n<p>Ability to understand and follow verbal and written work and safety instructions in English<\/p>\n<\/li>\n<li>\n<p>Ability to communicate effectively in English regarding job assignments, procedures, and safety standards<\/p>\n<\/li>\n<\/ul>\n<h2>Preferred Qualifications<\/h2>\n<ul>\n<li>\n<p>Bachelor\u2019s degree in a technical or mining-related discipline<\/p>\n<\/li>\n<\/ul>\n<h2>Work Environment &amp; Requirements<\/h2>\n<ul>\n<li>\n<p>Required use of personal protective equipment (PPE) in mine, outdoor, plant, or manufacturing environments, including hard hat, safety glasses, hearing protection, safety footwear, and other PPE as required<\/p>\n<\/li>\n<li>\n<p>Ability to comply with Turner Staffing Group and client drug- and alcohol-free workplace policies, including pre-employment and ongoing testing as permitted by applicable laws<\/p><\/li><\/ul>","%category%":"Operations","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/1b0938abb6bc-autonomous-mining-systems-coordinator","%breezy_id%":"1b0938abb6bc","%breezy_friendly_id%":"1b0938abb6bc-autonomous-mining-systems-coordinator","%breezy_created_date%":"2026-02-02T16:46:13.739Z","%breezy_updated_date%":"2026-02-02T16:46:47.025Z","%_wpgmp_location_city%":"Bagdad","%_wpgmp_location_state%":"AZ","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Bagdad, AZ, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"34.5722212","%_wpgmp_metabox_longitude%":"-113.1784322","%rank_math_internal_links_processed%":"1"}},"id":3118,"infowindow_disable":false},{"source":"post","title":"Sign Fabricator","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Sign Fabricator\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Primary Responsibilities of the position are: Fabrication of aluminum shapes, structures and components Fabrication of channel letters, cabinet signs, pole&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/sign-fabricator\/\" name=\"Sign Fabricator\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Primary Responsibilities of the position are: Fabrication of aluminum shapes, structures and components Fabrication of channel letters, cabinet signs, pole&hellip;","address":"El Cajon, CA, USA","location":{"lat":"32.7947731","city":"El Cajon","state":"CA","country":"United States","lng":"-116.9625269","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/sign-fabricator\/","zoom":19,"extra_fields":{"post_excerpt":"Primary Responsibilities of the position are: Fabrication of aluminum shapes, structures and components Fabrication of channel letters, cabinet signs, pole&hellip;","post_content":"<p>Primary Responsibilities of the position are:<\/p>\n<ul><li>Fabrication of aluminum shapes, structures and components<\/li><li>Fabrication of channel letters, cabinet signs, pole and pylon signs, architectural signs<\/li><li>Operation of electronic brake and other fabrication equipment<\/li><li>Extensive aluminum metal fabrication<\/li><li>Extensive aluminum welding<\/li><li>Moderate stainless steel or steel fabrication &amp; welding<\/li><li>Eye for accuracy and attention to detail<\/li><li>Fabricate to instructions, prints and details specifically<\/li><li>Assist fabricators with all aspects of fabrication<\/li><\/ul>\n<p><\/p>\n<p>Qualified Applicants will Possess:<\/p>\n<ul><li>3+ yrs experience in metal fabrication<\/li><li>3+ yrs experience welding aluminum and steel (Certification a plus)<\/li><li>Ability to read and understand fabrication blueprints<\/li><li>Good mathematical skills for measurements and calculations<\/li><li>Dependable attendance record<\/li><li>Ability to work well with others as a part of a team<\/li><li>Ability to work overtime periodically<\/li><li>Proven record of ability to work to deadlines<\/li><\/ul>","post_title":"Sign Fabricator","post_link":"https:\/\/turnerstaffing.com\/position\/sign-fabricator\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Mid Level","%location_country%":"United States","%location_city%":"El Cajon","%location_state_id%":"CA","%location_state_name%":"California","%location_city_state%":"El Cajon, CA","%education%":"Unspecified","%department%":"","%description%":"<p>Primary Responsibilities of the position are:<\/p>\n<ul><li>Fabrication of aluminum shapes, structures and components<\/li><li>Fabrication of channel letters, cabinet signs, pole and pylon signs, architectural signs<\/li><li>Operation of electronic brake and other fabrication equipment<\/li><li>Extensive aluminum metal fabrication<\/li><li>Extensive aluminum welding<\/li><li>Moderate stainless steel or steel fabrication &amp; welding<\/li><li>Eye for accuracy and attention to detail<\/li><li>Fabricate to instructions, prints and details specifically<\/li><li>Assist fabricators with all aspects of fabrication<\/li><\/ul>\n<p><\/p>\n<p>Qualified Applicants will Possess:<\/p>\n<ul><li>3+ yrs experience in metal fabrication<\/li><li>3+ yrs experience welding aluminum and steel (Certification a plus)<\/li><li>Ability to read and understand fabrication blueprints<\/li><li>Good mathematical skills for measurements and calculations<\/li><li>Dependable attendance record<\/li><li>Ability to work well with others as a part of a team<\/li><li>Ability to work overtime periodically<\/li><li>Proven record of ability to work to deadlines<\/li><\/ul>","%category%":"Operations","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/5c170bb8cc14-sign-fabricator","%breezy_id%":"5c170bb8cc14","%breezy_friendly_id%":"5c170bb8cc14-sign-fabricator","%breezy_created_date%":"2026-02-02T19:17:46.299Z","%breezy_updated_date%":"2026-02-02T19:18:20.280Z","%_wpgmp_location_city%":"El Cajon","%_wpgmp_location_state%":"CA","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"El Cajon, CA, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"32.7947731","%_wpgmp_metabox_longitude%":"-116.9625269","%rank_math_internal_links_processed%":"1"}},"id":3119,"infowindow_disable":false},{"source":"post","title":"Field Service Mechanic\/Machinist","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Field Service Mechanic\/Machinist\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    What You Will Do As a maintenance professional placed through Turner Staffing Group, you will support site operations by performing&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/field-service-mechanic-machinist\/\" name=\"Field Service Mechanic\/Machinist\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"What You Will Do As a maintenance professional placed through Turner Staffing Group, you will support site operations by performing&hellip;","address":"Morenci, AZ, USA","location":{"lat":"33.0508859","city":"Morenci","state":"AZ","country":"United States","lng":"-109.3280282","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/field-service-mechanic-machinist\/","zoom":19,"extra_fields":{"post_excerpt":"What You Will Do As a maintenance professional placed through Turner Staffing Group, you will support site operations by performing&hellip;","post_content":"<h2>What You Will Do<\/h2>\n<p>As a maintenance professional placed through <strong>Turner Staffing Group<\/strong>, you will support site operations by performing a wide range of mechanical maintenance and repair activities. Responsibilities include:<\/p>\n<ul>\n<li>\n<p>Performing routine and corrective maintenance activities<\/p>\n<\/li>\n<li>\n<p>Developing effective solutions for a variety of mechanical and maintenance situations<\/p>\n<\/li>\n<li>\n<p>Completing work orders and required maintenance documentation accurately and timely<\/p>\n<\/li>\n<li>\n<p>Training and mentoring maintenance personnel as needed<\/p>\n<\/li>\n<li>\n<p>Performing additional duties as assigned to support site operations<\/p>\n<\/li>\n<\/ul>\n<h2>What You Bring<\/h2>\n<ul>\n<li>\n<p>Minimum of <strong>four (4) years<\/strong> of experience in one or more of the following crafts:<\/p>\n<ul>\n<li>\n<p>Machinist<\/p>\n<\/li>\n<li>\n<p>Line Boring<\/p>\n<\/li>\n<li>\n<p>Welding<\/p>\n<\/li>\n<li>\n<p>Boilermaker<\/p>\n<\/li>\n<\/ul>\n<\/li>\n<li>\n<p>Demonstrated completion of required academic and practical competencies<\/p>\n<\/li>\n<li>\n<p>Proven mechanical aptitude with the ability to apply technical knowledge and skills in the field<\/p>\n<\/li>\n<li>\n<p>Ability to pass written and\/or practical assessments related to technical skills, knowledge, and safety, as required<\/p>\n<\/li>\n<li>\n<p>Proficiency in welding and cutting processes<\/p>\n<\/li>\n<li>\n<p>Ability to safely operate the following equipment:<\/p>\n<ul>\n<li>\n<p>11\u201d, 20\u201d, 24\u201d, and 32\u201d lathes<\/p>\n<\/li>\n<li>\n<p>Vertical and horizontal milling machines<\/p>\n<\/li>\n<li>\n<p>Marvel band saw<\/p>\n<\/li>\n<li>\n<p>Drill press<\/p>\n<\/li>\n<\/ul>\n<\/li>\n<li>\n<p>Ability to understand and follow verbal and written work and safety instructions in English<\/p>\n<\/li>\n<li>\n<p>Ability to communicate effectively in English regarding job assignments, procedures, and safety standards<\/p>\n<\/li>\n<\/ul>\n<h2>Preferred Qualifications<\/h2>\n<ul>\n<li>\n<p>High school diploma or GED<\/p>\n<\/li>\n<li>\n<p>Experience working on Komatsu electric shovels (4100XPA, 4100XPB\/C, 4100XPC\/AC)<\/p>\n<\/li>\n<li>\n<p>Experience working on Epiroc diesel drills (PV271, PV271XC)<\/p>\n<\/li>\n<\/ul>\n<h2>Compensation &amp; Benefits<\/h2>\n<ul>\n<li>\n<p><strong>Estimated pay range:<\/strong> $27.00 \u2013 $37.00 per hour, based on experience and qualifications<\/p>\n<\/li>\n<li>\n<p>Housing allowance may be available for employees required to work on-site, subject to assignment and client guidelines<\/p>\n<\/li>\n<li>\n<p>Medical, dental, and vision insurance options<\/p>\n<\/li>\n<li>\n<p>Company-paid life and disability insurance<\/p>\n<\/li>\n<li>\n<p>401(k) with employer contribution or match (where applicable)<\/p>\n<\/li>\n<li>\n<p>Paid time off, sick time, holidays, and parental leave<\/p>\n<\/li>\n<li>\n<p>Tuition assistance<\/p>\n<\/li>\n<li>\n<p>Employee Assistance Program (EAP)<\/p>\n<\/li>\n<li>\n<p>Voluntary insurance options for pet, auto, home, and vehicle<\/p>\n<\/li>\n<li>\n<p>Opportunities for career development and internal progression<\/p>\n<\/li>\n<\/ul>\n<p>Benefit eligibility and offerings may vary by assignment and will be discussed during the hiring process.<\/p>\n<h2>What We Require<\/h2>\n<ul>\n<li>\n<p>Ability to pass a pre-employment medical exam, if required<\/p>\n<\/li>\n<li>\n<p>Successful completion of all required training and testing<\/p>\n<\/li>\n<li>\n<p>Willingness to work non-standard schedules, including shift work, in a 24\/7, 365-day operation<\/p>\n<\/li>\n<li>\n<p>Compliance with Turner Staffing Group and client drug- and alcohol-free workplace policies, including pre-employment and ongoing testing as permitted by law<\/p><\/li><\/ul>","post_title":"Field Service Mechanic\/Machinist","post_link":"https:\/\/turnerstaffing.com\/position\/field-service-mechanic-machinist\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Mid Level","%location_country%":"United States","%location_city%":"Morenci","%location_state_id%":"AZ","%location_state_name%":"Arizona","%location_city_state%":"Morenci, AZ","%education%":"High School or Equivalent","%department%":"","%description%":"<h2>What You Will Do<\/h2>\n<p>As a maintenance professional placed through <strong>Turner Staffing Group<\/strong>, you will support site operations by performing a wide range of mechanical maintenance and repair activities. Responsibilities include:<\/p>\n<ul>\n<li>\n<p>Performing routine and corrective maintenance activities<\/p>\n<\/li>\n<li>\n<p>Developing effective solutions for a variety of mechanical and maintenance situations<\/p>\n<\/li>\n<li>\n<p>Completing work orders and required maintenance documentation accurately and timely<\/p>\n<\/li>\n<li>\n<p>Training and mentoring maintenance personnel as needed<\/p>\n<\/li>\n<li>\n<p>Performing additional duties as assigned to support site operations<\/p>\n<\/li>\n<\/ul>\n<h2>What You Bring<\/h2>\n<ul>\n<li>\n<p>Minimum of <strong>four (4) years<\/strong> of experience in one or more of the following crafts:<\/p>\n<ul>\n<li>\n<p>Machinist<\/p>\n<\/li>\n<li>\n<p>Line Boring<\/p>\n<\/li>\n<li>\n<p>Welding<\/p>\n<\/li>\n<li>\n<p>Boilermaker<\/p>\n<\/li>\n<\/ul>\n<\/li>\n<li>\n<p>Demonstrated completion of required academic and practical competencies<\/p>\n<\/li>\n<li>\n<p>Proven mechanical aptitude with the ability to apply technical knowledge and skills in the field<\/p>\n<\/li>\n<li>\n<p>Ability to pass written and\/or practical assessments related to technical skills, knowledge, and safety, as required<\/p>\n<\/li>\n<li>\n<p>Proficiency in welding and cutting processes<\/p>\n<\/li>\n<li>\n<p>Ability to safely operate the following equipment:<\/p>\n<ul>\n<li>\n<p>11\u201d, 20\u201d, 24\u201d, and 32\u201d lathes<\/p>\n<\/li>\n<li>\n<p>Vertical and horizontal milling machines<\/p>\n<\/li>\n<li>\n<p>Marvel band saw<\/p>\n<\/li>\n<li>\n<p>Drill press<\/p>\n<\/li>\n<\/ul>\n<\/li>\n<li>\n<p>Ability to understand and follow verbal and written work and safety instructions in English<\/p>\n<\/li>\n<li>\n<p>Ability to communicate effectively in English regarding job assignments, procedures, and safety standards<\/p>\n<\/li>\n<\/ul>\n<h2>Preferred Qualifications<\/h2>\n<ul>\n<li>\n<p>High school diploma or GED<\/p>\n<\/li>\n<li>\n<p>Experience working on Komatsu electric shovels (4100XPA, 4100XPB\/C, 4100XPC\/AC)<\/p>\n<\/li>\n<li>\n<p>Experience working on Epiroc diesel drills (PV271, PV271XC)<\/p>\n<\/li>\n<\/ul>\n<h2>Compensation &amp; Benefits<\/h2>\n<ul>\n<li>\n<p><strong>Estimated pay range:<\/strong> $27.00 \u2013 $37.00 per hour, based on experience and qualifications<\/p>\n<\/li>\n<li>\n<p>Housing allowance may be available for employees required to work on-site, subject to assignment and client guidelines<\/p>\n<\/li>\n<li>\n<p>Medical, dental, and vision insurance options<\/p>\n<\/li>\n<li>\n<p>Company-paid life and disability insurance<\/p>\n<\/li>\n<li>\n<p>401(k) with employer contribution or match (where applicable)<\/p>\n<\/li>\n<li>\n<p>Paid time off, sick time, holidays, and parental leave<\/p>\n<\/li>\n<li>\n<p>Tuition assistance<\/p>\n<\/li>\n<li>\n<p>Employee Assistance Program (EAP)<\/p>\n<\/li>\n<li>\n<p>Voluntary insurance options for pet, auto, home, and vehicle<\/p>\n<\/li>\n<li>\n<p>Opportunities for career development and internal progression<\/p>\n<\/li>\n<\/ul>\n<p>Benefit eligibility and offerings may vary by assignment and will be discussed during the hiring process.<\/p>\n<h2>What We Require<\/h2>\n<ul>\n<li>\n<p>Ability to pass a pre-employment medical exam, if required<\/p>\n<\/li>\n<li>\n<p>Successful completion of all required training and testing<\/p>\n<\/li>\n<li>\n<p>Willingness to work non-standard schedules, including shift work, in a 24\/7, 365-day operation<\/p>\n<\/li>\n<li>\n<p>Compliance with Turner Staffing Group and client drug- and alcohol-free workplace policies, including pre-employment and ongoing testing as permitted by law<\/p><\/li><\/ul>","%category%":"Operations","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/14f425933446-field-service-mechanic-machinist","%breezy_id%":"14f425933446","%breezy_friendly_id%":"14f425933446-field-service-mechanic-machinist","%breezy_created_date%":"2026-02-02T14:44:58.312Z","%breezy_updated_date%":"2026-02-02T14:45:38.679Z","%_wpgmp_location_city%":"Morenci","%_wpgmp_location_state%":"AZ","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Morenci, AZ, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"33.0508859","%_wpgmp_metabox_longitude%":"-109.3280282","%rank_math_internal_links_processed%":"1"}},"id":3115,"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    What You Will Do As a Heavy Equipment Operator placed through Turner Staffing Group, you will support production and site&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":"What You Will Do As a Heavy Equipment Operator placed through Turner Staffing Group, you will support production and site&hellip;","address":"Bagdad, AZ, USA","location":{"lat":"34.5722212","city":"Bagdad","state":"AZ","country":"United States","lng":"-113.1784322","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/heavy-equipment-operator-4\/","zoom":19,"extra_fields":{"post_excerpt":"What You Will Do As a Heavy Equipment Operator placed through Turner Staffing Group, you will support production and site&hellip;","post_content":"<h2>What You Will Do<\/h2>\n<p>As a Heavy Equipment Operator placed through <strong>Turner Staffing Group<\/strong>, you will support production and site operations by safely operating mobile equipment and performing surface maintenance activities. Responsibilities include:<\/p>\n<ul>\n<li>\n<p>Operating heavy equipment to support production activities such as dewatering, material delivery, berm maintenance, and surface upkeep<\/p>\n<\/li>\n<li>\n<p>Operating equipment that may include haul trucks, water trucks, rubber-tire and track dozers, excavators, motor graders, and front-end loaders<\/p>\n<\/li>\n<li>\n<p>Assisting with the training and mentoring of other equipment operators as needed<\/p>\n<\/li>\n<li>\n<p>Maintaining awareness of changes within assigned work areas and identifying potential hazards<\/p>\n<\/li>\n<li>\n<p>Following required operating and safety procedures, including start-up and shutdown, parking, mounting and dismounting, Lock-Out\/Tag-Out\/Try-Out (LOTOTO), emergency and fire response, working around ground personnel, and Blue Stake requirements<\/p>\n<\/li>\n<li>\n<p>Performing duties such as road construction, stockpile management, road surface maintenance, building and maintaining road berms, loading trucks, and trenching<\/p>\n<\/li>\n<li>\n<p>Understanding equipment components and operating practices that minimize wear and prevent damage<\/p>\n<\/li>\n<li>\n<p>Supporting operations through activities such as barricading shovels and assisting with power cable moves<\/p>\n<\/li>\n<li>\n<p>Completing pre-shift equipment inspections<\/p>\n<\/li>\n<li>\n<p>Communicating effectively via computerized dispatch systems or two-way radio<\/p>\n<\/li>\n<li>\n<p>Performing minor maintenance activities as required<\/p>\n<\/li>\n<li>\n<p>Completing additional duties as assigned<\/p>\n<\/li>\n<\/ul>\n<h2>What You Bring<\/h2>\n<ul>\n<li>\n<p>Minimum of <strong>six (6) months<\/strong> of mobile heavy equipment operating experience<\/p>\n<\/li>\n<li>\n<p>Completion of required academic and practical competencies<\/p>\n<\/li>\n<li>\n<p>Demonstrated ability to apply operating knowledge and skills in the field<\/p>\n<\/li>\n<li>\n<p>Ability to pass written and\/or practical assessments related to skills, knowledge, and safety, as required<\/p>\n<\/li>\n<\/ul>\n<h2>Preferred Qualifications<\/h2>\n<ul>\n<li>\n<p>High school diploma or GED<\/p><\/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%":"Bagdad","%location_state_id%":"AZ","%location_state_name%":"Arizona","%location_city_state%":"Bagdad, AZ","%education%":"Unspecified","%department%":"","%description%":"<h2>What You Will Do<\/h2>\n<p>As a Heavy Equipment Operator placed through <strong>Turner Staffing Group<\/strong>, you will support production and site operations by safely operating mobile equipment and performing surface maintenance activities. Responsibilities include:<\/p>\n<ul>\n<li>\n<p>Operating heavy equipment to support production activities such as dewatering, material delivery, berm maintenance, and surface upkeep<\/p>\n<\/li>\n<li>\n<p>Operating equipment that may include haul trucks, water trucks, rubber-tire and track dozers, excavators, motor graders, and front-end loaders<\/p>\n<\/li>\n<li>\n<p>Assisting with the training and mentoring of other equipment operators as needed<\/p>\n<\/li>\n<li>\n<p>Maintaining awareness of changes within assigned work areas and identifying potential hazards<\/p>\n<\/li>\n<li>\n<p>Following required operating and safety procedures, including start-up and shutdown, parking, mounting and dismounting, Lock-Out\/Tag-Out\/Try-Out (LOTOTO), emergency and fire response, working around ground personnel, and Blue Stake requirements<\/p>\n<\/li>\n<li>\n<p>Performing duties such as road construction, stockpile management, road surface maintenance, building and maintaining road berms, loading trucks, and trenching<\/p>\n<\/li>\n<li>\n<p>Understanding equipment components and operating practices that minimize wear and prevent damage<\/p>\n<\/li>\n<li>\n<p>Supporting operations through activities such as barricading shovels and assisting with power cable moves<\/p>\n<\/li>\n<li>\n<p>Completing pre-shift equipment inspections<\/p>\n<\/li>\n<li>\n<p>Communicating effectively via computerized dispatch systems or two-way radio<\/p>\n<\/li>\n<li>\n<p>Performing minor maintenance activities as required<\/p>\n<\/li>\n<li>\n<p>Completing additional duties as assigned<\/p>\n<\/li>\n<\/ul>\n<h2>What You Bring<\/h2>\n<ul>\n<li>\n<p>Minimum of <strong>six (6) months<\/strong> of mobile heavy equipment operating experience<\/p>\n<\/li>\n<li>\n<p>Completion of required academic and practical competencies<\/p>\n<\/li>\n<li>\n<p>Demonstrated ability to apply operating knowledge and skills in the field<\/p>\n<\/li>\n<li>\n<p>Ability to pass written and\/or practical assessments related to skills, knowledge, and safety, as required<\/p>\n<\/li>\n<\/ul>\n<h2>Preferred Qualifications<\/h2>\n<ul>\n<li>\n<p>High school diploma or GED<\/p><\/li><\/ul>","%category%":"Operations","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/2be890594083-heavy-equipment-operator","%breezy_id%":"2be890594083","%breezy_friendly_id%":"2be890594083-heavy-equipment-operator","%breezy_created_date%":"2026-02-02T15:29:26.439Z","%breezy_updated_date%":"2026-02-02T15:29:58.254Z","%_wpgmp_location_city%":"Bagdad","%_wpgmp_location_state%":"AZ","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Bagdad, AZ, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"34.5722212","%_wpgmp_metabox_longitude%":"-113.1784322","%rank_math_internal_links_processed%":"1"}},"id":3116,"infowindow_disable":false},{"source":"post","title":"Mine Manager","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Mine Manager\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Turner Mining Group &#8211; Project Manager &#8211; Mining A challenging and rewarding opportunity for a senior project manager with experience&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/mine-manager\/\" name=\"Mine Manager\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Turner Mining Group &#8211; Project Manager &#8211; Mining A challenging and rewarding opportunity for a senior project manager with experience&hellip;","address":"Soda Springs, ID, USA","location":{"lat":"42.6543652","city":"Soda Springs","state":"ID","country":"United States","lng":"-111.6046687","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/mine-manager\/","zoom":19,"extra_fields":{"post_excerpt":"Turner Mining Group &#8211; Project Manager &#8211; Mining A challenging and rewarding opportunity for a senior project manager with experience&hellip;","post_content":"<p><strong><u>Turner Mining Group - Project Manager - Mining<\/u><\/strong><\/p>\n<p>A challenging and rewarding opportunity for a senior project manager with experience in the mining industry!<br><\/p>\n<p>We are looking for a talented Project Manager to lead the development and execution of a large-scale production mining projects. The Project Manager will be responsible for managing the project scope, schedule, budget, quality, safety, and stakeholder relations. The Project Manager will also oversee the engineering, procurement, construction, commissioning, and operation phases of the project.<\/p>\n<p><strong>Responsibilities:<\/strong><br><\/p>\n<ul><li>Develop and implement the project strategy, plan, and governance framework based on data analysis and best practices<\/li><li>Manage the project team and vendors using data-driven tools and metrics<\/li><li>Ensure the project meets the technical, regulatory, and environmental requirements using data validation and verification methods<\/li><li>Monitor and control the project performance, risks, issues, and changes using data visualization and reporting techniques<\/li><li>Report and communicate the project status, progress, and outcomes to the senior management and the client using data storytelling and presentation skills<\/li><li>Ensure the project adheres to the highest standards of health, safety, and quality using data collection and evaluation systems<\/li><li>Facilitate the smooth transition from construction to operation using data integration and automation solutions<\/li><\/ul>\n<p><strong>Qualifications:<\/strong><\/p>\n<ul><li>Bachelor's degree in engineering, project management, or related field<\/li><li>Minimum 10 years of experience in managing large-scale capital projects in the mining industry<\/li><li>Proven track record of delivering projects on time, on budget, and on quality using data-driven approaches<\/li><li>Strong critical thinking, leadership, communication, negotiation, and problem-solving skills with a data-oriented mindset<\/li><li>Ability to work effectively in a fast-paced and dynamic environment with data complexity and uncertainty<\/li><\/ul>\n<p><strong>Benefits:<\/strong><\/p>\n<p>Turner Mining Group offers a competitive salary with additional opportunities to earn, an excellent work culture, career advancement opportunities. Turner Mining Group offers a benefits program which includes Medical, Dental, Vision, Life, and a 401k with company match.&nbsp;<\/p>\n<p>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":"Mine Manager","post_link":"https:\/\/turnerstaffing.com\/position\/mine-manager\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Senior","%location_country%":"United States","%location_city%":"Soda Springs","%location_state_id%":"ID","%location_state_name%":"Idaho","%location_city_state%":"Soda Springs, ID","%education%":"","%department%":"Operations","%description%":"<p><strong><u>Turner Mining Group - Project Manager - Mining<\/u><\/strong><\/p>\n<p>A challenging and rewarding opportunity for a senior project manager with experience in the mining industry!<br><\/p>\n<p>We are looking for a talented Project Manager to lead the development and execution of a large-scale production mining projects. The Project Manager will be responsible for managing the project scope, schedule, budget, quality, safety, and stakeholder relations. The Project Manager will also oversee the engineering, procurement, construction, commissioning, and operation phases of the project.<\/p>\n<p><strong>Responsibilities:<\/strong><br><\/p>\n<ul><li>Develop and implement the project strategy, plan, and governance framework based on data analysis and best practices<\/li><li>Manage the project team and vendors using data-driven tools and metrics<\/li><li>Ensure the project meets the technical, regulatory, and environmental requirements using data validation and verification methods<\/li><li>Monitor and control the project performance, risks, issues, and changes using data visualization and reporting techniques<\/li><li>Report and communicate the project status, progress, and outcomes to the senior management and the client using data storytelling and presentation skills<\/li><li>Ensure the project adheres to the highest standards of health, safety, and quality using data collection and evaluation systems<\/li><li>Facilitate the smooth transition from construction to operation using data integration and automation solutions<\/li><\/ul>\n<p><strong>Qualifications:<\/strong><\/p>\n<ul><li>Bachelor's degree in engineering, project management, or related field<\/li><li>Minimum 10 years of experience in managing large-scale capital projects in the mining industry<\/li><li>Proven track record of delivering projects on time, on budget, and on quality using data-driven approaches<\/li><li>Strong critical thinking, leadership, communication, negotiation, and problem-solving skills with a data-oriented mindset<\/li><li>Ability to work effectively in a fast-paced and dynamic environment with data complexity and uncertainty<\/li><\/ul>\n<p><strong>Benefits:<\/strong><\/p>\n<p>Turner Mining Group offers a competitive salary with additional opportunities to earn, an excellent work culture, career advancement opportunities. Turner Mining Group offers a benefits program which includes Medical, Dental, Vision, Life, and a 401k with company match.&nbsp;<\/p>\n<p>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\/9fb0daa556d4-mine-manager","%breezy_id%":"9fb0daa556d4","%breezy_friendly_id%":"9fb0daa556d4-mine-manager","%breezy_created_date%":"2025-09-03T12:33:26.801Z","%breezy_updated_date%":"2026-02-02T19:36:11.987Z","%_wpgmp_location_city%":"Soda Springs","%_wpgmp_location_state%":"ID","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Soda Springs, ID, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"42.6543652","%_wpgmp_metabox_longitude%":"-111.6046687","%rank_math_internal_links_processed%":"1"}},"id":3114,"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    What You Will Do As a Heavy Equipment Operator working through Turner Staffing Group, you will support mining production and&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":"What You Will Do As a Heavy Equipment Operator working through Turner Staffing Group, you will support mining production and&hellip;","address":"Leadville, CO, USA","location":{"lat":"39.2508229","city":"Leadville","state":"CO","country":"United States","lng":"-106.2925238","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/heavy-equipment-operator-2\/","zoom":19,"extra_fields":{"post_excerpt":"What You Will Do As a Heavy Equipment Operator working through Turner Staffing Group, you will support mining production and&hellip;","post_content":"<h3>What You Will Do<\/h3>\n<p>As a Heavy Equipment Operator working through <strong>Turner Staffing Group<\/strong>, you will support mining production and site operations by safely operating mobile equipment and performing surface maintenance activities. Responsibilities include:<\/p>\n<ul>\n<li>\n<p>Operating heavy equipment to support production, including dewatering, material delivery, berm maintenance, and surface upkeep<\/p>\n<\/li>\n<li>\n<p>Operating equipment that may include haul trucks, water trucks, rubber-tire and track dozers, excavators, motor graders, and front-end loaders<\/p>\n<\/li>\n<li>\n<p>Assisting with the training and mentoring of other equipment operators as needed<\/p>\n<\/li>\n<li>\n<p>Maintaining awareness of assigned work areas and identifying potential hazards<\/p>\n<\/li>\n<li>\n<p>Following required operating procedures, including start-up and shutdown, parking, mounting and dismounting, Lock-Out\/Tag-Out\/Try-Out (LOTOTO), emergency response, fire procedures, working around ground personnel, and Blue Stake requirements<\/p>\n<\/li>\n<li>\n<p>Performing duties such as road construction, stockpile management, road surface maintenance, building and maintaining berms, loading trucks, and trenching<\/p>\n<\/li>\n<li>\n<p>Understanding equipment components and operating practices that minimize wear and damage<\/p>\n<\/li>\n<li>\n<p>Supporting operations through activities such as barricading shovels and assisting with power cable moves<\/p>\n<\/li>\n<li>\n<p>Completing pre-shift equipment inspections<\/p>\n<\/li>\n<li>\n<p>Communicating via two-way radio or computerized dispatch systems<\/p>\n<\/li>\n<li>\n<p>Performing minor maintenance activities as required<\/p>\n<\/li>\n<li>\n<p>Completing additional duties as assigned to support site operations<\/p>\n<\/li>\n<\/ul>\n<h3>What You Bring<\/h3>\n<ul>\n<li>\n<p>Minimum of <strong>two (2) years&nbsp;<\/strong>of mobile heavy equipment operating experience<\/p>\n<\/li>\n<li>\n<p>Demonstrated completion of required academic and practical competencies<\/p>\n<\/li>\n<li>\n<p>Ability to apply technical knowledge and operating skills in a production environment<\/p>\n<\/li>\n<li>\n<p>Ability to pass written and\/or practical assessments related to skills, knowledge, and safety, as required<\/p>\n<\/li>\n<\/ul>\n<h3>Preferred Qualifications<\/h3>\n<ul>\n<li>\n<p>High school diploma or GED<\/p><\/li><\/ul>","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%":"Mid Level","%location_country%":"United States","%location_city%":"Leadville","%location_state_id%":"CO","%location_state_name%":"Colorado","%location_city_state%":"Leadville, CO","%education%":"High School or Equivalent","%department%":"","%description%":"<h3>What You Will Do<\/h3>\n<p>As a Heavy Equipment Operator working through <strong>Turner Staffing Group<\/strong>, you will support mining production and site operations by safely operating mobile equipment and performing surface maintenance activities. Responsibilities include:<\/p>\n<ul>\n<li>\n<p>Operating heavy equipment to support production, including dewatering, material delivery, berm maintenance, and surface upkeep<\/p>\n<\/li>\n<li>\n<p>Operating equipment that may include haul trucks, water trucks, rubber-tire and track dozers, excavators, motor graders, and front-end loaders<\/p>\n<\/li>\n<li>\n<p>Assisting with the training and mentoring of other equipment operators as needed<\/p>\n<\/li>\n<li>\n<p>Maintaining awareness of assigned work areas and identifying potential hazards<\/p>\n<\/li>\n<li>\n<p>Following required operating procedures, including start-up and shutdown, parking, mounting and dismounting, Lock-Out\/Tag-Out\/Try-Out (LOTOTO), emergency response, fire procedures, working around ground personnel, and Blue Stake requirements<\/p>\n<\/li>\n<li>\n<p>Performing duties such as road construction, stockpile management, road surface maintenance, building and maintaining berms, loading trucks, and trenching<\/p>\n<\/li>\n<li>\n<p>Understanding equipment components and operating practices that minimize wear and damage<\/p>\n<\/li>\n<li>\n<p>Supporting operations through activities such as barricading shovels and assisting with power cable moves<\/p>\n<\/li>\n<li>\n<p>Completing pre-shift equipment inspections<\/p>\n<\/li>\n<li>\n<p>Communicating via two-way radio or computerized dispatch systems<\/p>\n<\/li>\n<li>\n<p>Performing minor maintenance activities as required<\/p>\n<\/li>\n<li>\n<p>Completing additional duties as assigned to support site operations<\/p>\n<\/li>\n<\/ul>\n<h3>What You Bring<\/h3>\n<ul>\n<li>\n<p>Minimum of <strong>two (2) years&nbsp;<\/strong>of mobile heavy equipment operating experience<\/p>\n<\/li>\n<li>\n<p>Demonstrated completion of required academic and practical competencies<\/p>\n<\/li>\n<li>\n<p>Ability to apply technical knowledge and operating skills in a production environment<\/p>\n<\/li>\n<li>\n<p>Ability to pass written and\/or practical assessments related to skills, knowledge, and safety, as required<\/p>\n<\/li>\n<\/ul>\n<h3>Preferred Qualifications<\/h3>\n<ul>\n<li>\n<p>High school diploma or GED<\/p><\/li><\/ul>","%category%":"Operations","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/0d72b9b4b747-heavy-equipment-operator","%breezy_id%":"0d72b9b4b747","%breezy_friendly_id%":"0d72b9b4b747-heavy-equipment-operator","%breezy_created_date%":"2026-01-30T13:50:43.419Z","%breezy_updated_date%":"2026-01-30T13:51:14.418Z","%_wpgmp_location_city%":"Leadville","%_wpgmp_location_state%":"CO","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Leadville, CO, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"39.2508229","%_wpgmp_metabox_longitude%":"-106.2925238","%rank_math_internal_links_processed%":"1"}},"id":3112,"infowindow_disable":false},{"source":"post","title":"Electrical Design Lead","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Electrical Design Lead\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    What You Will Do The Electrical Design Lead, placed through Turner Staffing Group, plays a critical role in guiding the&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/electrical-design-lead\/\" name=\"Electrical Design Lead\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"What You Will Do The Electrical Design Lead, placed through Turner Staffing Group, plays a critical role in guiding the&hellip;","address":"New Orleans, LA, USA","location":{"lat":"29.9508941","city":"New Orleans","state":"LA","country":"United States","lng":"-90.0758356","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/electrical-design-lead\/","zoom":19,"extra_fields":{"post_excerpt":"What You Will Do The Electrical Design Lead, placed through Turner Staffing Group, plays a critical role in guiding the&hellip;","post_content":"<h2>What You Will Do<\/h2>\n<p>The <strong>Electrical Design Lead<\/strong>, placed through <strong>Turner Staffing Group<\/strong>, plays a critical role in guiding the strategic direction of engineering design projects from concept through execution. This position establishes and enforces CAD best practices, leads design teams, and promotes a culture of technical excellence, innovation, and efficiency across the project lifecycle.<\/p>\n<p>Key responsibilities include:<\/p>\n<ul>\n<li>\n<p>Leading, managing, training, and mentoring a team of electrical designers<\/p>\n<\/li>\n<li>\n<p>Establishing design objectives and technical specifications aligned with project goals<\/p>\n<\/li>\n<li>\n<p>Ensuring quality, consistency, and compliance across all electrical design deliverables<\/p>\n<\/li>\n<li>\n<p>Developing, documenting, and implementing CAD standards and best practices<\/p>\n<\/li>\n<li>\n<p>Coordinating and leading design reviews and project CAD setup activities<\/p>\n<\/li>\n<li>\n<p>Managing design resource allocation in coordination with engineering leadership<\/p>\n<\/li>\n<li>\n<p>Evaluating design personnel skillsets prior to project mobilization<\/p>\n<\/li>\n<li>\n<p>Collaborating with multi-discipline engineering teams to develop procedural interfaces<\/p>\n<\/li>\n<li>\n<p>Working with software vendors to resolve technical and application issues<\/p>\n<\/li>\n<li>\n<p>Managing project schedules and budgets related to design execution<\/p>\n<\/li>\n<li>\n<p>Educating engineering staff on design software capabilities and functionality<\/p>\n<\/li>\n<li>\n<p>Ensuring compliance with applicable industry standards, codes, and safety regulations<\/p>\n<\/li>\n<li>\n<p>Performing additional duties as required to support project execution<\/p>\n<\/li>\n<\/ul>\n<h2>What You Bring<\/h2>\n<ul>\n<li>\n<p>High School Diploma or GED <strong>and<\/strong> nine (9) years of related engineering design experience, including leadership of design professionals, process development, and execution, <strong>OR<\/strong><\/p>\n<\/li>\n<li>\n<p>Bachelor\u2019s degree in a related scientific or engineering discipline <strong>and<\/strong> five (5) years of engineering design experience, including leadership of design professionals, process development, and execution<\/p>\n<\/li>\n<\/ul>\n<h2>Preferred Qualifications<\/h2>\n<ul>\n<li>\n<p>Associate degree in Drafting and Design or a closely related field<\/p>\n<\/li>\n<li>\n<p>Proven expertise leading transitions to new design or CAD software platforms<\/p>\n<\/li>\n<li>\n<p>Demonstrated experience developing, documenting, and implementing CAD standards of practice<\/p>\n<\/li>\n<li>\n<p>Strong proficiency with industry-standard CAD tools<\/p>\n<\/li>\n<li>\n<p>Excellent leadership, communication, and project management skills<\/p>\n<\/li>\n<li>\n<p>Demonstrated ability to manage complex design projects and deliver results on schedule<\/p>\n<\/li>\n<li>\n<p>Working knowledge of applicable industry standards and regulations (e.g., ISO, ANSI, ASME)<\/p>\n<\/li>\n<li>\n<p>Understanding of efficient plant and facility layout principles<\/p><\/li><\/ul>","post_title":"Electrical Design Lead","post_link":"https:\/\/turnerstaffing.com\/position\/electrical-design-lead\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Senior","%location_country%":"United States","%location_city%":"New Orleans","%location_state_id%":"LA","%location_state_name%":"Louisiana","%location_city_state%":"New Orleans, LA","%education%":"High School or Equivalent","%department%":"","%description%":"<h2>What You Will Do<\/h2>\n<p>The <strong>Electrical Design Lead<\/strong>, placed through <strong>Turner Staffing Group<\/strong>, plays a critical role in guiding the strategic direction of engineering design projects from concept through execution. This position establishes and enforces CAD best practices, leads design teams, and promotes a culture of technical excellence, innovation, and efficiency across the project lifecycle.<\/p>\n<p>Key responsibilities include:<\/p>\n<ul>\n<li>\n<p>Leading, managing, training, and mentoring a team of electrical designers<\/p>\n<\/li>\n<li>\n<p>Establishing design objectives and technical specifications aligned with project goals<\/p>\n<\/li>\n<li>\n<p>Ensuring quality, consistency, and compliance across all electrical design deliverables<\/p>\n<\/li>\n<li>\n<p>Developing, documenting, and implementing CAD standards and best practices<\/p>\n<\/li>\n<li>\n<p>Coordinating and leading design reviews and project CAD setup activities<\/p>\n<\/li>\n<li>\n<p>Managing design resource allocation in coordination with engineering leadership<\/p>\n<\/li>\n<li>\n<p>Evaluating design personnel skillsets prior to project mobilization<\/p>\n<\/li>\n<li>\n<p>Collaborating with multi-discipline engineering teams to develop procedural interfaces<\/p>\n<\/li>\n<li>\n<p>Working with software vendors to resolve technical and application issues<\/p>\n<\/li>\n<li>\n<p>Managing project schedules and budgets related to design execution<\/p>\n<\/li>\n<li>\n<p>Educating engineering staff on design software capabilities and functionality<\/p>\n<\/li>\n<li>\n<p>Ensuring compliance with applicable industry standards, codes, and safety regulations<\/p>\n<\/li>\n<li>\n<p>Performing additional duties as required to support project execution<\/p>\n<\/li>\n<\/ul>\n<h2>What You Bring<\/h2>\n<ul>\n<li>\n<p>High School Diploma or GED <strong>and<\/strong> nine (9) years of related engineering design experience, including leadership of design professionals, process development, and execution, <strong>OR<\/strong><\/p>\n<\/li>\n<li>\n<p>Bachelor\u2019s degree in a related scientific or engineering discipline <strong>and<\/strong> five (5) years of engineering design experience, including leadership of design professionals, process development, and execution<\/p>\n<\/li>\n<\/ul>\n<h2>Preferred Qualifications<\/h2>\n<ul>\n<li>\n<p>Associate degree in Drafting and Design or a closely related field<\/p>\n<\/li>\n<li>\n<p>Proven expertise leading transitions to new design or CAD software platforms<\/p>\n<\/li>\n<li>\n<p>Demonstrated experience developing, documenting, and implementing CAD standards of practice<\/p>\n<\/li>\n<li>\n<p>Strong proficiency with industry-standard CAD tools<\/p>\n<\/li>\n<li>\n<p>Excellent leadership, communication, and project management skills<\/p>\n<\/li>\n<li>\n<p>Demonstrated ability to manage complex design projects and deliver results on schedule<\/p>\n<\/li>\n<li>\n<p>Working knowledge of applicable industry standards and regulations (e.g., ISO, ANSI, ASME)<\/p>\n<\/li>\n<li>\n<p>Understanding of efficient plant and facility layout principles<\/p><\/li><\/ul>","%category%":"Design","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/f110d2d84ec4-electrical-design-lead","%breezy_id%":"f110d2d84ec4","%breezy_friendly_id%":"f110d2d84ec4-electrical-design-lead","%breezy_created_date%":"2026-01-30T15:13:08.152Z","%breezy_updated_date%":"2026-01-30T15:13:38.849Z","%_wpgmp_location_city%":"New Orleans","%_wpgmp_location_state%":"LA","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"New Orleans, LA, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"29.9508941","%_wpgmp_metabox_longitude%":"-90.0758356","%rank_math_internal_links_processed%":"1"}},"id":3113,"infowindow_disable":false},{"source":"post","title":"Electrician- Crushers and Conveyors","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Electrician- Crushers and Conveyors\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    What You Will Do As an Electrician supporting crushing and conveying operations, you will be responsible for the safe and&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/electrician-crushers-and-conveyors-2\/\" name=\"Electrician- Crushers and Conveyors\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"What You Will Do As an Electrician supporting crushing and conveying operations, you will be responsible for the safe and&hellip;","address":"Safford, AZ, USA","location":{"lat":"32.8339546","city":"Safford","state":"AZ","country":"United States","lng":"-109.70758","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/electrician-crushers-and-conveyors-2\/","zoom":19,"extra_fields":{"post_excerpt":"What You Will Do As an Electrician supporting crushing and conveying operations, you will be responsible for the safe and&hellip;","post_content":"<h3>What You Will Do<\/h3>\n<p>As an Electrician supporting crushing and conveying operations, you will be responsible for the safe and effective maintenance, troubleshooting, and installation of industrial electrical systems. Responsibilities include:<\/p>\n<ul>\n<li>\n<p>Removal, repair, and installation of electrical components and systems<\/p>\n<\/li>\n<li>\n<p>Advanced troubleshooting, diagnostics, and system optimization<\/p>\n<\/li>\n<li>\n<p>Preventative and corrective maintenance on industrial electrical and instrumentation equipment, including:<\/p>\n<ul>\n<li>\n<p>Substations and power distribution systems<\/p>\n<\/li>\n<li>\n<p>Switchgear, motors, motor controls, and drives<\/p>\n<\/li>\n<li>\n<p>PLCs, process control systems, and instrumentation<\/p>\n<\/li>\n<li>\n<p>Pneumatic systems and field devices<\/p>\n<\/li>\n<\/ul>\n<\/li>\n<li>\n<p>Maintenance and troubleshooting of AC\/DC drives, PLCs, overhead cranes, control systems, and low- to medium-voltage equipment<\/p>\n<\/li>\n<li>\n<p>Calibration of transmitters, transducers, and weigh scales<\/p>\n<\/li>\n<li>\n<p>Performing work in compliance with regulatory and safety standards<\/p>\n<\/li>\n<li>\n<p>Following all SOPs, work instructions, and safety\/environmental protocols<\/p>\n<\/li>\n<li>\n<p>Safely completing both routine and non-routine repairs and construction tasks<\/p>\n<\/li>\n<li>\n<p>Mentoring or assisting other electrical workers as needed<\/p>\n<\/li>\n<\/ul>\n<h3>What You Bring<\/h3>\n<p>One of the following is required:<\/p>\n<ul>\n<li>\n<p>Completion of a certified electronics, electrical, or instrumentation program, <strong>OR<\/strong><\/p>\n<\/li>\n<li>\n<p>Minimum of four (4) years of industrial electrical and\/or instrumentation maintenance experience, <strong>OR<\/strong><\/p>\n<\/li>\n<li>\n<p>Associate degree or trade school certification in a related field plus two (2) years of relevant experience<\/p>\n<\/li>\n<\/ul>\n<p>Additional qualifications include:<\/p>\n<ul>\n<li>\n<p>Strong troubleshooting skills with the ability to read and interpret schematics, prints, and technical manuals<\/p>\n<\/li>\n<li>\n<p>Experience maintaining and repairing electrical circuits and connected equipment<\/p>\n<\/li>\n<li>\n<p>Effective written and verbal communication skills<\/p>\n<\/li>\n<li>\n<p>Ownership of required personal tools (or ability to obtain them within 90 days of assignment start)<\/p>\n<\/li>\n<li>\n<p>Ability to demonstrate required technical aptitude through assessments or evaluations, if required<\/p>\n<\/li>\n<\/ul>\n<h3>Preferred Qualifications<\/h3>\n<ul>\n<li>\n<p>High school diploma or GED<\/p>\n<\/li>\n<li>\n<p>Experience with VFDs, PLCs, and HMIs<\/p>\n<\/li>\n<li>\n<p>Experience working with low- and medium-voltage systems<\/p>\n<\/li>\n<li>\n<p>Background in AC and\/or DC controls<\/p>\n<\/li>\n<li>\n<p>Experience with industrial instrumentation devices<\/p>\n<\/li>\n<li>\n<p>Familiarity with diagnostic and test equipment<\/p><\/li><\/ul>","post_title":"Electrician- Crushers and Conveyors","post_link":"https:\/\/turnerstaffing.com\/position\/electrician-crushers-and-conveyors-2\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Mid Level","%location_country%":"United States","%location_city%":"Safford","%location_state_id%":"AZ","%location_state_name%":"Arizona","%location_city_state%":"Safford, AZ","%education%":"High School or Equivalent","%department%":"","%description%":"<h3>What You Will Do<\/h3>\n<p>As an Electrician supporting crushing and conveying operations, you will be responsible for the safe and effective maintenance, troubleshooting, and installation of industrial electrical systems. Responsibilities include:<\/p>\n<ul>\n<li>\n<p>Removal, repair, and installation of electrical components and systems<\/p>\n<\/li>\n<li>\n<p>Advanced troubleshooting, diagnostics, and system optimization<\/p>\n<\/li>\n<li>\n<p>Preventative and corrective maintenance on industrial electrical and instrumentation equipment, including:<\/p>\n<ul>\n<li>\n<p>Substations and power distribution systems<\/p>\n<\/li>\n<li>\n<p>Switchgear, motors, motor controls, and drives<\/p>\n<\/li>\n<li>\n<p>PLCs, process control systems, and instrumentation<\/p>\n<\/li>\n<li>\n<p>Pneumatic systems and field devices<\/p>\n<\/li>\n<\/ul>\n<\/li>\n<li>\n<p>Maintenance and troubleshooting of AC\/DC drives, PLCs, overhead cranes, control systems, and low- to medium-voltage equipment<\/p>\n<\/li>\n<li>\n<p>Calibration of transmitters, transducers, and weigh scales<\/p>\n<\/li>\n<li>\n<p>Performing work in compliance with regulatory and safety standards<\/p>\n<\/li>\n<li>\n<p>Following all SOPs, work instructions, and safety\/environmental protocols<\/p>\n<\/li>\n<li>\n<p>Safely completing both routine and non-routine repairs and construction tasks<\/p>\n<\/li>\n<li>\n<p>Mentoring or assisting other electrical workers as needed<\/p>\n<\/li>\n<\/ul>\n<h3>What You Bring<\/h3>\n<p>One of the following is required:<\/p>\n<ul>\n<li>\n<p>Completion of a certified electronics, electrical, or instrumentation program, <strong>OR<\/strong><\/p>\n<\/li>\n<li>\n<p>Minimum of four (4) years of industrial electrical and\/or instrumentation maintenance experience, <strong>OR<\/strong><\/p>\n<\/li>\n<li>\n<p>Associate degree or trade school certification in a related field plus two (2) years of relevant experience<\/p>\n<\/li>\n<\/ul>\n<p>Additional qualifications include:<\/p>\n<ul>\n<li>\n<p>Strong troubleshooting skills with the ability to read and interpret schematics, prints, and technical manuals<\/p>\n<\/li>\n<li>\n<p>Experience maintaining and repairing electrical circuits and connected equipment<\/p>\n<\/li>\n<li>\n<p>Effective written and verbal communication skills<\/p>\n<\/li>\n<li>\n<p>Ownership of required personal tools (or ability to obtain them within 90 days of assignment start)<\/p>\n<\/li>\n<li>\n<p>Ability to demonstrate required technical aptitude through assessments or evaluations, if required<\/p>\n<\/li>\n<\/ul>\n<h3>Preferred Qualifications<\/h3>\n<ul>\n<li>\n<p>High school diploma or GED<\/p>\n<\/li>\n<li>\n<p>Experience with VFDs, PLCs, and HMIs<\/p>\n<\/li>\n<li>\n<p>Experience working with low- and medium-voltage systems<\/p>\n<\/li>\n<li>\n<p>Background in AC and\/or DC controls<\/p>\n<\/li>\n<li>\n<p>Experience with industrial instrumentation devices<\/p>\n<\/li>\n<li>\n<p>Familiarity with diagnostic and test equipment<\/p><\/li><\/ul>","%category%":"Operations","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/0f6baadcaca7-electrician-crushers-and-conveyors","%breezy_id%":"0f6baadcaca7","%breezy_friendly_id%":"0f6baadcaca7-electrician-crushers-and-conveyors","%breezy_created_date%":"2026-01-30T12:28:07.067Z","%breezy_updated_date%":"2026-01-30T12:28:28.205Z","%_wpgmp_location_city%":"Safford","%_wpgmp_location_state%":"AZ","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Safford, AZ, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"32.8339546","%_wpgmp_metabox_longitude%":"-109.70758","%rank_math_internal_links_processed%":"1"}},"id":3108,"infowindow_disable":false},{"source":"post","title":"Crane Operator","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Crane Operator\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Position Overview Turner Staffing Group is seeking an experienced Crane Operator to support industrial and mining operations. This role is&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/crane-operator\/\" name=\"Crane Operator\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Position Overview Turner Staffing Group is seeking an experienced Crane Operator to support industrial and mining operations. This role is&hellip;","address":"Bagdad, AZ, USA","location":{"lat":"34.5722212","city":"Bagdad","state":"AZ","country":"United States","lng":"-113.1784322","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/crane-operator\/","zoom":19,"extra_fields":{"post_excerpt":"Position Overview Turner Staffing Group is seeking an experienced Crane Operator to support industrial and mining operations. This role is&hellip;","post_content":"<h3>Position Overview<\/h3>\n<p>Turner Staffing Group is seeking an experienced <strong>Crane Operator<\/strong> to support industrial and mining operations. This role is responsible for the safe operation, inspection, and basic maintenance of mobile cranes, boom trucks, and related lifting equipment in a 24\/7 operating environment.<\/p>\n<h3>Key Responsibilities<\/h3>\n<ul>\n<li>\n<p>Safely operate all types of cranes and boom trucks, including cranes with capacities up to <strong>150 tons<\/strong><\/p>\n<\/li>\n<li>\n<p>Conduct equipment inspections and assist with inspection documentation for cranes, boom trucks, and forklifts<\/p>\n<\/li>\n<li>\n<p>Perform minor equipment repairs and support preventative maintenance activities<\/p>\n<\/li>\n<li>\n<p>Follow load charts, rigging procedures, and crane safety protocols at all times<\/p>\n<\/li>\n<li>\n<p>Participate in site safety programs including JSAs, SOPs, behavioral safety audits, near-miss reporting, and other safety initiatives<\/p>\n<\/li>\n<li>\n<p>Support site management in complying with safety, environmental, and operational policies<\/p>\n<\/li>\n<li>\n<p>Assist with crane load testing and cable reeling activities<\/p>\n<\/li>\n<li>\n<p>Maintain accurate records and communicate effectively with site leadership and team members<\/p>\n<\/li>\n<li>\n<p>Perform additional duties as assigned to support site operations<\/p>\n<\/li>\n<\/ul>\n<h3>Minimum Qualifications<\/h3>\n<ul>\n<li>\n<p>Minimum of <strong>two (2) years<\/strong> of experience as a mobile crane operator in an industrial maintenance, construction, or mining environment<\/p>\n<\/li>\n<li>\n<p>Experience operating large mobile cranes (150-ton capacity or greater), boom trucks, and forklifts<\/p>\n<\/li>\n<li>\n<p>Demonstrated knowledge of rigging practices, load charts, and crane inspection procedures<\/p>\n<\/li>\n<li>\n<p>Experience with mobile crane preventative maintenance and inspection processes<\/p>\n<\/li>\n<li>\n<p>Working knowledge of hydraulic systems<\/p>\n<\/li>\n<li>\n<p>Ability to read and interpret technical manuals, blueprints, and schematics<\/p>\n<\/li>\n<li>\n<p>Strong safety awareness with a proven record of safe work practices and reliable attendance<\/p>\n<\/li>\n<li>\n<p>Ability to pass required written, hands-on, and skills assessments<\/p>\n<\/li>\n<li>\n<p>Ability to pass a physical exam, including color recognition and depth perception testing<\/p>\n<\/li>\n<li>\n<p>Willingness to work weekends, holidays, rotating shifts, scheduled and unscheduled overtime in a <strong>24\/7 operation<\/strong><\/p>\n<\/li>\n<li>\n<p>Ability to work overtime and respond to call-outs as required<\/p>\n<\/li>\n<\/ul>\n<h3>Preferred Qualifications<\/h3>\n<ul>\n<li>\n<p>High school diploma or GED<\/p>\n<\/li>\n<li>\n<p>Commercial Driver\u2019s License (CDL)<\/p>\n<\/li>\n<li>\n<p>Advanced computer skills, including Microsoft Office<\/p>\n<\/li>\n<li>\n<p>Leadership qualities with the ability to mentor and train others on safe crane operation<\/p>\n<\/li>\n<li>\n<p>Experience adapting to and learning new equipment<\/p>\n<\/li>\n<\/ul>\n<h3>Additional Requirements<\/h3>\n<ul>\n<li>\n<p>Regular and reliable attendance is an essential function of this role<\/p>\n<\/li>\n<li>\n<p>Must be self-motivated and capable of working independently and as part of a high-performance team<\/p>\n<\/li>\n<li>\n<p>Must comply with all Turner Staffing Group and client site safety, training, and drug-free workplace requirements<\/p><\/li><\/ul>","post_title":"Crane Operator","post_link":"https:\/\/turnerstaffing.com\/position\/crane-operator\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Mid Level","%location_country%":"United States","%location_city%":"Bagdad","%location_state_id%":"AZ","%location_state_name%":"Arizona","%location_city_state%":"Bagdad, AZ","%education%":"High School or Equivalent","%department%":"","%description%":"<h3>Position Overview<\/h3>\n<p>Turner Staffing Group is seeking an experienced <strong>Crane Operator<\/strong> to support industrial and mining operations. This role is responsible for the safe operation, inspection, and basic maintenance of mobile cranes, boom trucks, and related lifting equipment in a 24\/7 operating environment.<\/p>\n<h3>Key Responsibilities<\/h3>\n<ul>\n<li>\n<p>Safely operate all types of cranes and boom trucks, including cranes with capacities up to <strong>150 tons<\/strong><\/p>\n<\/li>\n<li>\n<p>Conduct equipment inspections and assist with inspection documentation for cranes, boom trucks, and forklifts<\/p>\n<\/li>\n<li>\n<p>Perform minor equipment repairs and support preventative maintenance activities<\/p>\n<\/li>\n<li>\n<p>Follow load charts, rigging procedures, and crane safety protocols at all times<\/p>\n<\/li>\n<li>\n<p>Participate in site safety programs including JSAs, SOPs, behavioral safety audits, near-miss reporting, and other safety initiatives<\/p>\n<\/li>\n<li>\n<p>Support site management in complying with safety, environmental, and operational policies<\/p>\n<\/li>\n<li>\n<p>Assist with crane load testing and cable reeling activities<\/p>\n<\/li>\n<li>\n<p>Maintain accurate records and communicate effectively with site leadership and team members<\/p>\n<\/li>\n<li>\n<p>Perform additional duties as assigned to support site operations<\/p>\n<\/li>\n<\/ul>\n<h3>Minimum Qualifications<\/h3>\n<ul>\n<li>\n<p>Minimum of <strong>two (2) years<\/strong> of experience as a mobile crane operator in an industrial maintenance, construction, or mining environment<\/p>\n<\/li>\n<li>\n<p>Experience operating large mobile cranes (150-ton capacity or greater), boom trucks, and forklifts<\/p>\n<\/li>\n<li>\n<p>Demonstrated knowledge of rigging practices, load charts, and crane inspection procedures<\/p>\n<\/li>\n<li>\n<p>Experience with mobile crane preventative maintenance and inspection processes<\/p>\n<\/li>\n<li>\n<p>Working knowledge of hydraulic systems<\/p>\n<\/li>\n<li>\n<p>Ability to read and interpret technical manuals, blueprints, and schematics<\/p>\n<\/li>\n<li>\n<p>Strong safety awareness with a proven record of safe work practices and reliable attendance<\/p>\n<\/li>\n<li>\n<p>Ability to pass required written, hands-on, and skills assessments<\/p>\n<\/li>\n<li>\n<p>Ability to pass a physical exam, including color recognition and depth perception testing<\/p>\n<\/li>\n<li>\n<p>Willingness to work weekends, holidays, rotating shifts, scheduled and unscheduled overtime in a <strong>24\/7 operation<\/strong><\/p>\n<\/li>\n<li>\n<p>Ability to work overtime and respond to call-outs as required<\/p>\n<\/li>\n<\/ul>\n<h3>Preferred Qualifications<\/h3>\n<ul>\n<li>\n<p>High school diploma or GED<\/p>\n<\/li>\n<li>\n<p>Commercial Driver\u2019s License (CDL)<\/p>\n<\/li>\n<li>\n<p>Advanced computer skills, including Microsoft Office<\/p>\n<\/li>\n<li>\n<p>Leadership qualities with the ability to mentor and train others on safe crane operation<\/p>\n<\/li>\n<li>\n<p>Experience adapting to and learning new equipment<\/p>\n<\/li>\n<\/ul>\n<h3>Additional Requirements<\/h3>\n<ul>\n<li>\n<p>Regular and reliable attendance is an essential function of this role<\/p>\n<\/li>\n<li>\n<p>Must be self-motivated and capable of working independently and as part of a high-performance team<\/p>\n<\/li>\n<li>\n<p>Must comply with all Turner Staffing Group and client site safety, training, and drug-free workplace requirements<\/p><\/li><\/ul>","%category%":"Operations","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/bb04a6372ed9-crane-operator","%breezy_id%":"bb04a6372ed9","%breezy_friendly_id%":"bb04a6372ed9-crane-operator","%breezy_created_date%":"2026-01-30T12:34:44.592Z","%breezy_updated_date%":"2026-01-30T12:35:17.977Z","%_wpgmp_location_city%":"Bagdad","%_wpgmp_location_state%":"AZ","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Bagdad, AZ, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"34.5722212","%_wpgmp_metabox_longitude%":"-113.1784322","%rank_math_internal_links_processed%":"1"}},"id":3109,"infowindow_disable":false},{"source":"post","title":"Crane Operator","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Crane Operator\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Position Overview Turner Staffing Group is seeking an experienced Crane Operator to support industrial and mining operations. This role is&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/crane-operator-2\/\" name=\"Crane Operator\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Position Overview Turner Staffing Group is seeking an experienced Crane Operator to support industrial and mining operations. This role is&hellip;","address":"Morenci, AZ, USA","location":{"lat":"33.0508859","city":"Morenci","state":"AZ","country":"United States","lng":"-109.3280282","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/crane-operator-2\/","zoom":19,"extra_fields":{"post_excerpt":"Position Overview Turner Staffing Group is seeking an experienced Crane Operator to support industrial and mining operations. This role is&hellip;","post_content":"<h3>Position Overview<\/h3>\n<p>Turner Staffing Group is seeking an experienced <strong>Crane Operator<\/strong> to support industrial and mining operations. This role is responsible for the safe operation, inspection, and basic maintenance of mobile cranes, boom trucks, and related lifting equipment in a 24\/7 operating environment.<\/p>\n<h3>Key Responsibilities<\/h3>\n<ul>\n<li>\n<p>Safely operate all types of cranes and boom trucks, including cranes with capacities up to <strong>150 tons<\/strong><\/p>\n<\/li>\n<li>\n<p>Conduct equipment inspections and assist with inspection documentation for cranes, boom trucks, and forklifts<\/p>\n<\/li>\n<li>\n<p>Perform minor equipment repairs and support preventative maintenance activities<\/p>\n<\/li>\n<li>\n<p>Follow load charts, rigging procedures, and crane safety protocols at all times<\/p>\n<\/li>\n<li>\n<p>Participate in site safety programs including JSAs, SOPs, behavioral safety audits, near-miss reporting, and other safety initiatives<\/p>\n<\/li>\n<li>\n<p>Support site management in complying with safety, environmental, and operational policies<\/p>\n<\/li>\n<li>\n<p>Assist with crane load testing and cable reeling activities<\/p>\n<\/li>\n<li>\n<p>Maintain accurate records and communicate effectively with site leadership and team members<\/p>\n<\/li>\n<li>\n<p>Perform additional duties as assigned to support site operations<\/p>\n<\/li>\n<\/ul>\n<h3>Minimum Qualifications<\/h3>\n<ul>\n<li>\n<p>Minimum of <strong>two (2) years<\/strong> of experience as a mobile crane operator in an industrial maintenance, construction, or mining environment<\/p>\n<\/li>\n<li>\n<p>Experience operating large mobile cranes (150-ton capacity or greater), boom trucks, and forklifts<\/p>\n<\/li>\n<li>\n<p>Demonstrated knowledge of rigging practices, load charts, and crane inspection procedures<\/p>\n<\/li>\n<li>\n<p>Experience with mobile crane preventative maintenance and inspection processes<\/p>\n<\/li>\n<li>\n<p>Working knowledge of hydraulic systems<\/p>\n<\/li>\n<li>\n<p>Ability to read and interpret technical manuals, blueprints, and schematics<\/p>\n<\/li>\n<li>\n<p>Strong safety awareness with a proven record of safe work practices and reliable attendance<\/p>\n<\/li>\n<li>\n<p>Ability to pass required written, hands-on, and skills assessments<\/p>\n<\/li>\n<li>\n<p>Ability to pass a physical exam, including color recognition and depth perception testing<\/p>\n<\/li>\n<li>\n<p>Willingness to work weekends, holidays, rotating shifts, scheduled and unscheduled overtime in a <strong>24\/7 operation<\/strong><\/p>\n<\/li>\n<li>\n<p>Ability to work overtime and respond to call-outs as required<\/p>\n<\/li>\n<\/ul>\n<h3>Preferred Qualifications<\/h3>\n<ul>\n<li>\n<p>High school diploma or GED<\/p>\n<\/li>\n<li>\n<p>Commercial Driver\u2019s License (CDL)<\/p>\n<\/li>\n<li>\n<p>Advanced computer skills, including Microsoft Office<\/p>\n<\/li>\n<li>\n<p>Leadership qualities with the ability to mentor and train others on safe crane operation<\/p>\n<\/li>\n<li>\n<p>Experience adapting to and learning new equipment<\/p>\n<\/li>\n<\/ul>\n<h3>Additional Requirements<\/h3>\n<ul>\n<li>\n<p>Regular and reliable attendance is an essential function of this role<\/p>\n<\/li>\n<li>\n<p>Must be self-motivated and capable of working independently and as part of a high-performance team<\/p>\n<\/li>\n<li>\n<p>Must comply with all Turner Staffing Group and client site safety, training, and drug-free workplace requirements<\/p><\/li><\/ul>","post_title":"Crane Operator","post_link":"https:\/\/turnerstaffing.com\/position\/crane-operator-2\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Mid Level","%location_country%":"United States","%location_city%":"Morenci","%location_state_id%":"AZ","%location_state_name%":"Arizona","%location_city_state%":"Morenci, AZ","%education%":"High School or Equivalent","%department%":"","%description%":"<h3>Position Overview<\/h3>\n<p>Turner Staffing Group is seeking an experienced <strong>Crane Operator<\/strong> to support industrial and mining operations. This role is responsible for the safe operation, inspection, and basic maintenance of mobile cranes, boom trucks, and related lifting equipment in a 24\/7 operating environment.<\/p>\n<h3>Key Responsibilities<\/h3>\n<ul>\n<li>\n<p>Safely operate all types of cranes and boom trucks, including cranes with capacities up to <strong>150 tons<\/strong><\/p>\n<\/li>\n<li>\n<p>Conduct equipment inspections and assist with inspection documentation for cranes, boom trucks, and forklifts<\/p>\n<\/li>\n<li>\n<p>Perform minor equipment repairs and support preventative maintenance activities<\/p>\n<\/li>\n<li>\n<p>Follow load charts, rigging procedures, and crane safety protocols at all times<\/p>\n<\/li>\n<li>\n<p>Participate in site safety programs including JSAs, SOPs, behavioral safety audits, near-miss reporting, and other safety initiatives<\/p>\n<\/li>\n<li>\n<p>Support site management in complying with safety, environmental, and operational policies<\/p>\n<\/li>\n<li>\n<p>Assist with crane load testing and cable reeling activities<\/p>\n<\/li>\n<li>\n<p>Maintain accurate records and communicate effectively with site leadership and team members<\/p>\n<\/li>\n<li>\n<p>Perform additional duties as assigned to support site operations<\/p>\n<\/li>\n<\/ul>\n<h3>Minimum Qualifications<\/h3>\n<ul>\n<li>\n<p>Minimum of <strong>two (2) years<\/strong> of experience as a mobile crane operator in an industrial maintenance, construction, or mining environment<\/p>\n<\/li>\n<li>\n<p>Experience operating large mobile cranes (150-ton capacity or greater), boom trucks, and forklifts<\/p>\n<\/li>\n<li>\n<p>Demonstrated knowledge of rigging practices, load charts, and crane inspection procedures<\/p>\n<\/li>\n<li>\n<p>Experience with mobile crane preventative maintenance and inspection processes<\/p>\n<\/li>\n<li>\n<p>Working knowledge of hydraulic systems<\/p>\n<\/li>\n<li>\n<p>Ability to read and interpret technical manuals, blueprints, and schematics<\/p>\n<\/li>\n<li>\n<p>Strong safety awareness with a proven record of safe work practices and reliable attendance<\/p>\n<\/li>\n<li>\n<p>Ability to pass required written, hands-on, and skills assessments<\/p>\n<\/li>\n<li>\n<p>Ability to pass a physical exam, including color recognition and depth perception testing<\/p>\n<\/li>\n<li>\n<p>Willingness to work weekends, holidays, rotating shifts, scheduled and unscheduled overtime in a <strong>24\/7 operation<\/strong><\/p>\n<\/li>\n<li>\n<p>Ability to work overtime and respond to call-outs as required<\/p>\n<\/li>\n<\/ul>\n<h3>Preferred Qualifications<\/h3>\n<ul>\n<li>\n<p>High school diploma or GED<\/p>\n<\/li>\n<li>\n<p>Commercial Driver\u2019s License (CDL)<\/p>\n<\/li>\n<li>\n<p>Advanced computer skills, including Microsoft Office<\/p>\n<\/li>\n<li>\n<p>Leadership qualities with the ability to mentor and train others on safe crane operation<\/p>\n<\/li>\n<li>\n<p>Experience adapting to and learning new equipment<\/p>\n<\/li>\n<\/ul>\n<h3>Additional Requirements<\/h3>\n<ul>\n<li>\n<p>Regular and reliable attendance is an essential function of this role<\/p>\n<\/li>\n<li>\n<p>Must be self-motivated and capable of working independently and as part of a high-performance team<\/p>\n<\/li>\n<li>\n<p>Must comply with all Turner Staffing Group and client site safety, training, and drug-free workplace requirements<\/p><\/li><\/ul>","%category%":"Operations","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/efd210012267-crane-operator","%breezy_id%":"efd210012267","%breezy_friendly_id%":"efd210012267-crane-operator","%breezy_created_date%":"2026-01-30T12:37:11.824Z","%breezy_updated_date%":"2026-01-30T12:37:22.078Z","%_wpgmp_location_city%":"Morenci","%_wpgmp_location_state%":"AZ","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Morenci, AZ, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"33.0508859","%_wpgmp_metabox_longitude%":"-109.3280282","%rank_math_internal_links_processed%":"1"}},"id":3110,"infowindow_disable":false},{"source":"post","title":"Senior Electrical Maintenance Supervisor","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Senior Electrical Maintenance Supervisor\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Position Overview Turner Staffing Group is seeking an experienced Senior Supervisor \u2013 Electrical Maintenance to support operations at a large&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/senior-electrical-maintenance-supervisor\/\" name=\"Senior Electrical Maintenance Supervisor\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Position Overview Turner Staffing Group is seeking an experienced Senior Supervisor \u2013 Electrical Maintenance to support operations at a large&hellip;","address":"Tucson, AZ, USA","location":{"lat":"32.2539787","city":"Tucson","state":"AZ","country":"United States","lng":"-110.9741769","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/senior-electrical-maintenance-supervisor\/","zoom":19,"extra_fields":{"post_excerpt":"Position Overview Turner Staffing Group is seeking an experienced Senior Supervisor \u2013 Electrical Maintenance to support operations at a large&hellip;","post_content":"<h3>Position Overview<\/h3>\n<p>Turner Staffing Group is seeking an experienced <strong>Senior Supervisor \u2013 Electrical Maintenance<\/strong> to support operations at a large mining and processing facility near Tucson, Arizona. This role is responsible for supervising and coordinating electrical maintenance operations through first-line supervisors while ensuring safe, efficient, and compliant production support.<\/p>\n<h3>Work Location<\/h3>\n<p>The position is based at a mining operation located approximately 20 miles from Tucson, AZ.&nbsp;<\/p>\n<h3>Key Responsibilities<\/h3>\n<ul>\n<li>\n<p>Supervise, coordinate, and control the safe and efficient operation of assigned electrical maintenance work units<\/p>\n<\/li>\n<li>\n<p>Directly oversee first-line and shift supervisors<\/p>\n<\/li>\n<li>\n<p>Ensure continued production support by executing maintenance plans and schedules<\/p>\n<\/li>\n<li>\n<p>Provide operational input for maintenance and production planning activities<\/p>\n<\/li>\n<li>\n<p>Enforce compliance with safety standards, operating procedures, and applicable federal and state regulations<\/p>\n<\/li>\n<li>\n<p>Inspect assigned work areas to confirm schedules, objectives, and performance targets are met<\/p>\n<\/li>\n<li>\n<p>Coordinate daily with cross-functional teams including Operations, Maintenance, Engineering, Safety, Environmental, and other support groups<\/p>\n<\/li>\n<li>\n<p>Identify and resolve day-to-day operational issues related to equipment, materials, methods, and procedures<\/p>\n<\/li>\n<li>\n<p>Support budget preparation, monitoring, and cost control efforts<\/p>\n<\/li>\n<li>\n<p>Perform additional duties as assigned<\/p>\n<\/li>\n<\/ul>\n<h3>Minimum Qualifications<\/h3>\n<ul>\n<li>\n<p>High school diploma or GED <strong>and<\/strong> seven (7) years of related operational experience, including supervisory or lead experience, <strong>OR<\/strong><\/p>\n<\/li>\n<li>\n<p>Bachelor\u2019s degree in a technical or mining-related discipline <strong>and<\/strong> three (3) years of operational experience, including supervisory or lead experience<\/p>\n<\/li>\n<li>\n<p>Additional certifications or licenses relevant to the role may be required<\/p>\n<\/li>\n<li>\n<p>Strong knowledge of supervisory methods and leadership practices<\/p>\n<\/li>\n<li>\n<p>Proven ability to manage safety, recognize hazards, and enforce safe work practices<\/p>\n<\/li>\n<li>\n<p>Experience resolving operational challenges involving equipment, materials, and procedures<\/p>\n<\/li>\n<li>\n<p>Strong communication skills, both written and verbal<\/p><\/li>\n<\/ul>\n<h3>Work Environment &amp; Physical Requirements<\/h3>\n<ul>\n<li>\n<p>Ability to understand and follow verbal and written instructions and safety procedures in English<\/p>\n<\/li>\n<li>\n<p>Ability to communicate effectively in English regarding job assignments and safety standards<\/p>\n<\/li>\n<li>\n<p>Willingness to work in a fast-paced and potentially high-stress environment<\/p>\n<\/li>\n<li>\n<p>Work is performed in a mine or industrial plant setting with exposure to temperature extremes, humidity, moving machinery, electrical hazards, chemicals, fumes, dust, and noise<\/p>\n<\/li>\n<li>\n<p>Regularly required to stand, sit, climb stairs and ladders, work at heights, and demonstrate manual dexterity<\/p>\n<\/li>\n<li>\n<p>Occasional lifting of materials up to 30 pounds<\/p>\n<\/li>\n<li>\n<p>Required use of personal protective equipment (PPE), including hard hat, safety glasses, hearing protection, safety footwear, gloves, and other PPE as required<\/p><\/li><\/ul>","post_title":"Senior Electrical Maintenance Supervisor","post_link":"https:\/\/turnerstaffing.com\/position\/senior-electrical-maintenance-supervisor\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Senior","%location_country%":"United States","%location_city%":"Tucson","%location_state_id%":"AZ","%location_state_name%":"Arizona","%location_city_state%":"Tucson, AZ","%education%":"High School or Equivalent","%department%":"","%description%":"<h3>Position Overview<\/h3>\n<p>Turner Staffing Group is seeking an experienced <strong>Senior Supervisor \u2013 Electrical Maintenance<\/strong> to support operations at a large mining and processing facility near Tucson, Arizona. This role is responsible for supervising and coordinating electrical maintenance operations through first-line supervisors while ensuring safe, efficient, and compliant production support.<\/p>\n<h3>Work Location<\/h3>\n<p>The position is based at a mining operation located approximately 20 miles from Tucson, AZ.&nbsp;<\/p>\n<h3>Key Responsibilities<\/h3>\n<ul>\n<li>\n<p>Supervise, coordinate, and control the safe and efficient operation of assigned electrical maintenance work units<\/p>\n<\/li>\n<li>\n<p>Directly oversee first-line and shift supervisors<\/p>\n<\/li>\n<li>\n<p>Ensure continued production support by executing maintenance plans and schedules<\/p>\n<\/li>\n<li>\n<p>Provide operational input for maintenance and production planning activities<\/p>\n<\/li>\n<li>\n<p>Enforce compliance with safety standards, operating procedures, and applicable federal and state regulations<\/p>\n<\/li>\n<li>\n<p>Inspect assigned work areas to confirm schedules, objectives, and performance targets are met<\/p>\n<\/li>\n<li>\n<p>Coordinate daily with cross-functional teams including Operations, Maintenance, Engineering, Safety, Environmental, and other support groups<\/p>\n<\/li>\n<li>\n<p>Identify and resolve day-to-day operational issues related to equipment, materials, methods, and procedures<\/p>\n<\/li>\n<li>\n<p>Support budget preparation, monitoring, and cost control efforts<\/p>\n<\/li>\n<li>\n<p>Perform additional duties as assigned<\/p>\n<\/li>\n<\/ul>\n<h3>Minimum Qualifications<\/h3>\n<ul>\n<li>\n<p>High school diploma or GED <strong>and<\/strong> seven (7) years of related operational experience, including supervisory or lead experience, <strong>OR<\/strong><\/p>\n<\/li>\n<li>\n<p>Bachelor\u2019s degree in a technical or mining-related discipline <strong>and<\/strong> three (3) years of operational experience, including supervisory or lead experience<\/p>\n<\/li>\n<li>\n<p>Additional certifications or licenses relevant to the role may be required<\/p>\n<\/li>\n<li>\n<p>Strong knowledge of supervisory methods and leadership practices<\/p>\n<\/li>\n<li>\n<p>Proven ability to manage safety, recognize hazards, and enforce safe work practices<\/p>\n<\/li>\n<li>\n<p>Experience resolving operational challenges involving equipment, materials, and procedures<\/p>\n<\/li>\n<li>\n<p>Strong communication skills, both written and verbal<\/p><\/li>\n<\/ul>\n<h3>Work Environment &amp; Physical Requirements<\/h3>\n<ul>\n<li>\n<p>Ability to understand and follow verbal and written instructions and safety procedures in English<\/p>\n<\/li>\n<li>\n<p>Ability to communicate effectively in English regarding job assignments and safety standards<\/p>\n<\/li>\n<li>\n<p>Willingness to work in a fast-paced and potentially high-stress environment<\/p>\n<\/li>\n<li>\n<p>Work is performed in a mine or industrial plant setting with exposure to temperature extremes, humidity, moving machinery, electrical hazards, chemicals, fumes, dust, and noise<\/p>\n<\/li>\n<li>\n<p>Regularly required to stand, sit, climb stairs and ladders, work at heights, and demonstrate manual dexterity<\/p>\n<\/li>\n<li>\n<p>Occasional lifting of materials up to 30 pounds<\/p>\n<\/li>\n<li>\n<p>Required use of personal protective equipment (PPE), including hard hat, safety glasses, hearing protection, safety footwear, gloves, and other PPE as required<\/p><\/li><\/ul>","%category%":"Management","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/1db701c3d0c2-senior-electrical-maintenance-supervisor","%breezy_id%":"1db701c3d0c2","%breezy_friendly_id%":"1db701c3d0c2-senior-electrical-maintenance-supervisor","%breezy_created_date%":"2026-01-30T12:41:59.252Z","%breezy_updated_date%":"2026-01-30T12:42:33.814Z","%_wpgmp_location_city%":"Tucson","%_wpgmp_location_state%":"AZ","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Tucson, AZ, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"32.2539787","%_wpgmp_metabox_longitude%":"-110.9741769","%rank_math_internal_links_processed%":"1"}},"id":3111,"infowindow_disable":false},{"source":"post","title":"Electrician- Crushers and Conveyors","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Electrician- Crushers and Conveyors\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    What You Will Do As an Electrician supporting crushing and conveying operations, you will be responsible for the safe and&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/electrician-crushers-and-conveyors\/\" name=\"Electrician- Crushers and Conveyors\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"What You Will Do As an Electrician supporting crushing and conveying operations, you will be responsible for the safe and&hellip;","address":"Morenci, AZ, USA","location":{"lat":"33.0508859","city":"Morenci","state":"AZ","country":"United States","lng":"-109.3280282","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/electrician-crushers-and-conveyors\/","zoom":19,"extra_fields":{"post_excerpt":"What You Will Do As an Electrician supporting crushing and conveying operations, you will be responsible for the safe and&hellip;","post_content":"<h3>What You Will Do<\/h3>\n<p>As an Electrician supporting crushing and conveying operations, you will be responsible for the safe and effective maintenance, troubleshooting, and installation of industrial electrical systems. Responsibilities include:<\/p>\n<ul>\n<li>\n<p>Removal, repair, and installation of electrical components and systems<\/p>\n<\/li>\n<li>\n<p>Advanced troubleshooting, diagnostics, and system optimization<\/p>\n<\/li>\n<li>\n<p>Preventative and corrective maintenance on industrial electrical and instrumentation equipment, including:<\/p>\n<ul>\n<li>\n<p>Substations and power distribution systems<\/p>\n<\/li>\n<li>\n<p>Switchgear, motors, motor controls, and drives<\/p>\n<\/li>\n<li>\n<p>PLCs, process control systems, and instrumentation<\/p>\n<\/li>\n<li>\n<p>Pneumatic systems and field devices<\/p>\n<\/li>\n<\/ul>\n<\/li>\n<li>\n<p>Maintenance and troubleshooting of AC\/DC drives, PLCs, overhead cranes, control systems, and low- to medium-voltage equipment<\/p>\n<\/li>\n<li>\n<p>Calibration of transmitters, transducers, and weigh scales<\/p>\n<\/li>\n<li>\n<p>Performing work in compliance with regulatory and safety standards<\/p>\n<\/li>\n<li>\n<p>Following all SOPs, work instructions, and safety\/environmental protocols<\/p>\n<\/li>\n<li>\n<p>Safely completing both routine and non-routine repairs and construction tasks<\/p>\n<\/li>\n<li>\n<p>Mentoring or assisting other electrical workers as needed<\/p>\n<\/li>\n<\/ul>\n<h3>What You Bring<\/h3>\n<p>One of the following is required:<\/p>\n<ul>\n<li>\n<p>Completion of a certified electronics, electrical, or instrumentation program, <strong>OR<\/strong><\/p>\n<\/li>\n<li>\n<p>Minimum of four (4) years of industrial electrical and\/or instrumentation maintenance experience, <strong>OR<\/strong><\/p>\n<\/li>\n<li>\n<p>Associate degree or trade school certification in a related field plus two (2) years of relevant experience<\/p>\n<\/li>\n<\/ul>\n<p>Additional qualifications include:<\/p>\n<ul>\n<li>\n<p>Strong troubleshooting skills with the ability to read and interpret schematics, prints, and technical manuals<\/p>\n<\/li>\n<li>\n<p>Experience maintaining and repairing electrical circuits and connected equipment<\/p>\n<\/li>\n<li>\n<p>Effective written and verbal communication skills<\/p>\n<\/li>\n<li>\n<p>Ownership of required personal tools (or ability to obtain them within 90 days of assignment start)<\/p>\n<\/li>\n<li>\n<p>Ability to demonstrate required technical aptitude through assessments or evaluations, if required<\/p>\n<\/li>\n<\/ul>\n<h3>Preferred Qualifications<\/h3>\n<ul>\n<li>\n<p>High school diploma or GED<\/p>\n<\/li>\n<li>\n<p>Experience with VFDs, PLCs, and HMIs<\/p>\n<\/li>\n<li>\n<p>Experience working with low- and medium-voltage systems<\/p>\n<\/li>\n<li>\n<p>Background in AC and\/or DC controls<\/p>\n<\/li>\n<li>\n<p>Experience with industrial instrumentation devices<\/p>\n<\/li>\n<li>\n<p>Familiarity with diagnostic and test equipment<\/p><\/li><\/ul>","post_title":"Electrician- Crushers and Conveyors","post_link":"https:\/\/turnerstaffing.com\/position\/electrician-crushers-and-conveyors\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Mid Level","%location_country%":"United States","%location_city%":"Morenci","%location_state_id%":"AZ","%location_state_name%":"Arizona","%location_city_state%":"Morenci, AZ","%education%":"High School or Equivalent","%department%":"","%description%":"<h3>What You Will Do<\/h3>\n<p>As an Electrician supporting crushing and conveying operations, you will be responsible for the safe and effective maintenance, troubleshooting, and installation of industrial electrical systems. Responsibilities include:<\/p>\n<ul>\n<li>\n<p>Removal, repair, and installation of electrical components and systems<\/p>\n<\/li>\n<li>\n<p>Advanced troubleshooting, diagnostics, and system optimization<\/p>\n<\/li>\n<li>\n<p>Preventative and corrective maintenance on industrial electrical and instrumentation equipment, including:<\/p>\n<ul>\n<li>\n<p>Substations and power distribution systems<\/p>\n<\/li>\n<li>\n<p>Switchgear, motors, motor controls, and drives<\/p>\n<\/li>\n<li>\n<p>PLCs, process control systems, and instrumentation<\/p>\n<\/li>\n<li>\n<p>Pneumatic systems and field devices<\/p>\n<\/li>\n<\/ul>\n<\/li>\n<li>\n<p>Maintenance and troubleshooting of AC\/DC drives, PLCs, overhead cranes, control systems, and low- to medium-voltage equipment<\/p>\n<\/li>\n<li>\n<p>Calibration of transmitters, transducers, and weigh scales<\/p>\n<\/li>\n<li>\n<p>Performing work in compliance with regulatory and safety standards<\/p>\n<\/li>\n<li>\n<p>Following all SOPs, work instructions, and safety\/environmental protocols<\/p>\n<\/li>\n<li>\n<p>Safely completing both routine and non-routine repairs and construction tasks<\/p>\n<\/li>\n<li>\n<p>Mentoring or assisting other electrical workers as needed<\/p>\n<\/li>\n<\/ul>\n<h3>What You Bring<\/h3>\n<p>One of the following is required:<\/p>\n<ul>\n<li>\n<p>Completion of a certified electronics, electrical, or instrumentation program, <strong>OR<\/strong><\/p>\n<\/li>\n<li>\n<p>Minimum of four (4) years of industrial electrical and\/or instrumentation maintenance experience, <strong>OR<\/strong><\/p>\n<\/li>\n<li>\n<p>Associate degree or trade school certification in a related field plus two (2) years of relevant experience<\/p>\n<\/li>\n<\/ul>\n<p>Additional qualifications include:<\/p>\n<ul>\n<li>\n<p>Strong troubleshooting skills with the ability to read and interpret schematics, prints, and technical manuals<\/p>\n<\/li>\n<li>\n<p>Experience maintaining and repairing electrical circuits and connected equipment<\/p>\n<\/li>\n<li>\n<p>Effective written and verbal communication skills<\/p>\n<\/li>\n<li>\n<p>Ownership of required personal tools (or ability to obtain them within 90 days of assignment start)<\/p>\n<\/li>\n<li>\n<p>Ability to demonstrate required technical aptitude through assessments or evaluations, if required<\/p>\n<\/li>\n<\/ul>\n<h3>Preferred Qualifications<\/h3>\n<ul>\n<li>\n<p>High school diploma or GED<\/p>\n<\/li>\n<li>\n<p>Experience with VFDs, PLCs, and HMIs<\/p>\n<\/li>\n<li>\n<p>Experience working with low- and medium-voltage systems<\/p>\n<\/li>\n<li>\n<p>Background in AC and\/or DC controls<\/p>\n<\/li>\n<li>\n<p>Experience with industrial instrumentation devices<\/p>\n<\/li>\n<li>\n<p>Familiarity with diagnostic and test equipment<\/p><\/li><\/ul>","%category%":"Operations","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/cc186fd812fd-electrician-crushers-and-conveyors","%breezy_id%":"cc186fd812fd","%breezy_friendly_id%":"cc186fd812fd-electrician-crushers-and-conveyors","%breezy_created_date%":"2026-01-30T12:26:30.353Z","%breezy_updated_date%":"2026-01-30T12:27:07.646Z","%_wpgmp_location_city%":"Morenci","%_wpgmp_location_state%":"AZ","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Morenci, AZ, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"33.0508859","%_wpgmp_metabox_longitude%":"-109.3280282","%rank_math_internal_links_processed%":"1"}},"id":3107,"infowindow_disable":false},{"source":"post","title":"Business Development Manager","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Business Development Manager\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    The Business Development Manager for Houston&nbsp;will work within a geographic area generating new business and growing existing relationships and accounts&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/business-development-manager\/\" name=\"Business Development Manager\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"The Business Development Manager for Houston&nbsp;will work within a geographic area generating new business and growing existing relationships and accounts&hellip;","address":"Houston, TX, USA","location":{"lat":"29.7600771","city":"Houston","state":"TX","country":"United States","lng":"-95.3701108","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/business-development-manager\/","zoom":19,"extra_fields":{"post_excerpt":"The Business Development Manager for Houston&nbsp;will work within a geographic area generating new business and growing existing relationships and accounts&hellip;","post_content":"<p>The <strong>Business Development Manager for Houston<\/strong>&nbsp;will work within a geographic area generating new business and growing existing relationships and accounts with current and previous clients. This is a sales role that is very technical in nature which will require knowledge of our products, methods, and selling to contractors. The incumbent should bring high energy, solid presentations skills and internal drive.<\/p>\n<p><strong>ESSENTIAL FUNCTIONS (WITH OR WITHOUT ACCOMMODATIONS):<\/strong><\/p>\n<ul>\n <li>Identifies      market opportunities, builds relationships with owners and potential      clients, and partner with customers relying on product knowledge and      experience to support bid specifications and close sales.<\/li>\n <li>Proactively      pursue and foster relationships with the appropriate representatives of      contractors and owners who may benefit from our products.<\/li>\n <li>Ensure      all activities and opportunities are tracked in our CRM and updated      timely. Utilize CRM to identify sales strategies based on historic data.<\/li>\n <li>Possess      and maintain thorough knowledge of our markets with respect to pricing,      opportunities, and strategy.<\/li>\n <li>Any      other duties as assigned<\/li>\n<\/ul>\n<p><strong>QUALIFICATIONS:<\/strong><\/p>\n<ul>\n <li>At      least three (3) years of experience in the utility construction, pipe      manufacturing\/sales, and\/or building materials<\/li>\n <li>Experience      as a project manager, estimator, or project engineer as a contractor in      comparable projects\/markets preferred but not required.<\/li>\n <li>Bachelor\u2019s      degree in related field.<\/li>\n <li>Strong      interpersonal and communication skills, verbal and written, with the      experience and ability to effectively build relationships and provide      expertise in support of opportunities.<\/li>\n <li>Proficient      in the Microsoft Office suite of products.<\/li>\n <li>Proficiency      using a CRM or related database too.<\/li>\n<\/ul>\n<p><strong>Desired Qualifications<\/strong><\/p>\n<ul>\n <li>Previous      experience in the pipe or underground utilities markets.<\/li>\n<\/ul>\n<p><strong>COMPETENCIES:<\/strong><\/p>\n<ul>\n <li>Planning\/Organizing:      Uses time efficiently; sets goals and objectives; develops realistic      action plans; Completes administrative duties to facilitate accounting,      payroll and HR departments; Collaborates with Company management on      special projects involving construction methods and processes to improve      the safety, quality and efficiency of the organization.<\/li>\n <li>Communication:      Listens and seeks clarification; Responds well to questions; participates      in meetings and demonstrates group discussion skills; Writes clearly and      informatively; Reads and interprets written information effectively;      Presents numerical data effectively.<\/li>\n <li>Self-Management:      Assess own strengths and weaknesses; Strives to continuously build      knowledge and skills; Demonstrates persistence and overcomes obstacles;      Seeks increased responsibilities and volunteers readily; Shares expertise      with others; Asks for and offers help when needed.<\/li>\n <li>Attendance\/Dependability\/Flexibility:      Consistently at work and meetings on time; Takes responsibility for own      actions; Follows directions; Keeps commitments and completes tasks on      time; Deals effectively with frequent delays, unexpected events and changes      in\/or approaches\/methods to best fit the situation.<\/li>\n <li>Quality\/Cost      Management: Meets productivity standards and completes work in timely      manner; Looks for ways to improve and promote safety and quality; Monitors      own work to ensure quality, accuracy and thoroughness; conserves      organizational resources.<\/li>\n <li>Interpersonal      Skills\/Professionalism: Focuses on solving conflict; Maintains      confidentiality; Reacts well under pressure; Interacts with managers and      peers in a professional manner.<\/li>\n <li>Teamwork:      Exhibits objectivity and openness to others' views; Gives and welcomes      feedback; Contributes to building a positive team spirit; Shows respect      and sensitivity for others; Includes necessary individuals in planning,      decision making, and process improvement.<\/li>\n<\/ul>","post_title":"Business Development Manager","post_link":"https:\/\/turnerstaffing.com\/position\/business-development-manager\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Associate","%location_country%":"United States","%location_city%":"Houston","%location_state_id%":"TX","%location_state_name%":"Texas","%location_city_state%":"Houston, TX","%education%":"Bachelor's Degree","%department%":"","%description%":"<p>The <strong>Business Development Manager for Houston<\/strong>&nbsp;will work within a geographic area generating new business and growing existing relationships and accounts with current and previous clients. This is a sales role that is very technical in nature which will require knowledge of our products, methods, and selling to contractors. The incumbent should bring high energy, solid presentations skills and internal drive.<\/p>\n<p><strong>ESSENTIAL FUNCTIONS (WITH OR WITHOUT ACCOMMODATIONS):<\/strong><\/p>\n<ul>\n <li>Identifies      market opportunities, builds relationships with owners and potential      clients, and partner with customers relying on product knowledge and      experience to support bid specifications and close sales.<\/li>\n <li>Proactively      pursue and foster relationships with the appropriate representatives of      contractors and owners who may benefit from our products.<\/li>\n <li>Ensure      all activities and opportunities are tracked in our CRM and updated      timely. Utilize CRM to identify sales strategies based on historic data.<\/li>\n <li>Possess      and maintain thorough knowledge of our markets with respect to pricing,      opportunities, and strategy.<\/li>\n <li>Any      other duties as assigned<\/li>\n<\/ul>\n<p><strong>QUALIFICATIONS:<\/strong><\/p>\n<ul>\n <li>At      least three (3) years of experience in the utility construction, pipe      manufacturing\/sales, and\/or building materials<\/li>\n <li>Experience      as a project manager, estimator, or project engineer as a contractor in      comparable projects\/markets preferred but not required.<\/li>\n <li>Bachelor\u2019s      degree in related field.<\/li>\n <li>Strong      interpersonal and communication skills, verbal and written, with the      experience and ability to effectively build relationships and provide      expertise in support of opportunities.<\/li>\n <li>Proficient      in the Microsoft Office suite of products.<\/li>\n <li>Proficiency      using a CRM or related database too.<\/li>\n<\/ul>\n<p><strong>Desired Qualifications<\/strong><\/p>\n<ul>\n <li>Previous      experience in the pipe or underground utilities markets.<\/li>\n<\/ul>\n<p><strong>COMPETENCIES:<\/strong><\/p>\n<ul>\n <li>Planning\/Organizing:      Uses time efficiently; sets goals and objectives; develops realistic      action plans; Completes administrative duties to facilitate accounting,      payroll and HR departments; Collaborates with Company management on      special projects involving construction methods and processes to improve      the safety, quality and efficiency of the organization.<\/li>\n <li>Communication:      Listens and seeks clarification; Responds well to questions; participates      in meetings and demonstrates group discussion skills; Writes clearly and      informatively; Reads and interprets written information effectively;      Presents numerical data effectively.<\/li>\n <li>Self-Management:      Assess own strengths and weaknesses; Strives to continuously build      knowledge and skills; Demonstrates persistence and overcomes obstacles;      Seeks increased responsibilities and volunteers readily; Shares expertise      with others; Asks for and offers help when needed.<\/li>\n <li>Attendance\/Dependability\/Flexibility:      Consistently at work and meetings on time; Takes responsibility for own      actions; Follows directions; Keeps commitments and completes tasks on      time; Deals effectively with frequent delays, unexpected events and changes      in\/or approaches\/methods to best fit the situation.<\/li>\n <li>Quality\/Cost      Management: Meets productivity standards and completes work in timely      manner; Looks for ways to improve and promote safety and quality; Monitors      own work to ensure quality, accuracy and thoroughness; conserves      organizational resources.<\/li>\n <li>Interpersonal      Skills\/Professionalism: Focuses on solving conflict; Maintains      confidentiality; Reacts well under pressure; Interacts with managers and      peers in a professional manner.<\/li>\n <li>Teamwork:      Exhibits objectivity and openness to others' views; Gives and welcomes      feedback; Contributes to building a positive team spirit; Shows respect      and sensitivity for others; Includes necessary individuals in planning,      decision making, and process improvement.<\/li>\n<\/ul>","%category%":"Sales","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/89a6c0b52b29-business-development-manager","%breezy_id%":"89a6c0b52b29","%breezy_friendly_id%":"89a6c0b52b29-business-development-manager","%breezy_created_date%":"2025-08-12T17:42:02.821Z","%breezy_updated_date%":"2026-01-30T17:32:41.111Z","%_wpgmp_location_city%":"Houston","%_wpgmp_location_state%":"TX","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Houston, TX, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"29.7600771","%_wpgmp_metabox_longitude%":"-95.3701108","%rank_math_internal_links_processed%":"1"}},"id":3106,"infowindow_disable":false},{"source":"post","title":"Industrial Electrician Apprentice &#8211; Mining","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Industrial Electrician Apprentice &#8211; Mining\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Job Summary The Electrician Apprentice supports Journeyman and Master Electricians in the installation, maintenance, troubleshooting, and repair of electrical systems&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/industrial-electrician-apprentice-mining\/\" name=\"Industrial Electrician Apprentice &#8211; Mining\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Job Summary The Electrician Apprentice supports Journeyman and Master Electricians in the installation, maintenance, troubleshooting, and repair of electrical systems&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\/industrial-electrician-apprentice-mining\/","zoom":19,"extra_fields":{"post_excerpt":"Job Summary The Electrician Apprentice supports Journeyman and Master Electricians in the installation, maintenance, troubleshooting, and repair of electrical systems&hellip;","post_content":"<h3><strong>Job Summary<\/strong><\/h3>\n<p>The Electrician Apprentice supports Journeyman and Master Electricians in the installation, maintenance, troubleshooting, and repair of electrical systems and equipment used in mining operations. This position is designed for individuals seeking hands-on experience in an industrial mining environment while developing the skills required to advance in the electrical trade.<\/p>\n<h3><strong>Key Responsibilities<\/strong><\/h3>\n<ul>\n<li>\n<p>Assist journeyman electricians with installing, maintaining, and repairing industrial electrical systems and mining equipment<\/p>\n<\/li>\n<li>\n<p>Support troubleshooting efforts on motors, conveyors, crushers, pumps, lighting, and power distribution systems<\/p>\n<\/li>\n<li>\n<p>Perform basic electrical tasks under direct supervision, including conduit installation, wire pulling, terminations, and component replacement<\/p>\n<\/li>\n<li>\n<p>Use electrical meters and hand tools to perform testing and inspections as directed<\/p>\n<\/li>\n<li>\n<p>Follow lockout\/tagout procedures and all MSHA, NEC, and site-specific safety regulations<\/p>\n<\/li>\n<li>\n<p>Maintain a clean and organized work area and properly care for tools and equipment<\/p>\n<\/li>\n<li>\n<p>Assist with preventative maintenance activities to reduce equipment downtime<\/p>\n<\/li>\n<li>\n<p>Learn to read and interpret electrical schematics, drawings, and technical manuals<\/p>\n<\/li>\n<li>\n<p>Communicate job progress and equipment issues to supervising electricians<\/p>\n<\/li>\n<li>\n<p>Participate in safety meetings, training, and apprenticeship-related coursework as required<\/p>\n<\/li>\n<\/ul>\n<h3><strong>Required Qualifications<\/strong><\/h3>\n<ul>\n<li>\n<p>Enrollment in an electrical apprenticeship program (or equivalent on-the-job training experience)<\/p>\n<\/li>\n<li>\n<p>Basic understanding of electrical theory and safety practices<\/p>\n<\/li>\n<li>\n<p>Willingness to learn and take direction in a production-focused environment<\/p>\n<\/li>\n<li>\n<p>Ability to work safely in industrial and mining conditions<\/p>\n<\/li>\n<li>\n<p>Must be able to pass required site-specific training, medical exams, and drug\/alcohol screening<\/p>\n<\/li>\n<\/ul>\n<h3><strong>Tools &amp; Equipment Requirement<\/strong><\/h3>\n<ul>\n<li>\n<p><strong>Apprentices must furnish their own basic electrical hand tools and meters<\/strong>, appropriate for apprentice-level work<\/p>\n<\/li>\n<li>\n<p>Specialty tools, PPE, and site-specific equipment will be provided by the employer<\/p>\n<\/li>\n<\/ul>\n<h3><strong>Physical &amp; Work Environment<\/strong><\/h3>\n<ul>\n<li>\n<p>Work is performed in an active mining environment with exposure to dust, noise, vibration, and varying weather conditions<\/p>\n<\/li>\n<li>\n<p>Must be able to lift up to 50 lbs., climb ladders, and work in confined spaces or at heights<\/p>\n<\/li>\n<\/ul>\n<h3><strong>Preferred Qualifications<\/strong><\/h3>\n<ul>\n<li>\n<p>Previous industrial, construction, or mining experience<\/p>\n<\/li>\n<li>\n<p>MSHA certification or willingness to obtain<\/p>\n<\/li>\n<li>\n<p>Coursework completed toward an electrical apprenticeship<\/p>\n<\/li>\n<\/ul><p><\/p>","post_title":"Industrial Electrician Apprentice &#8211; Mining","post_link":"https:\/\/turnerstaffing.com\/position\/industrial-electrician-apprentice-mining\/","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%":"<h3><strong>Job Summary<\/strong><\/h3>\n<p>The Electrician Apprentice supports Journeyman and Master Electricians in the installation, maintenance, troubleshooting, and repair of electrical systems and equipment used in mining operations. This position is designed for individuals seeking hands-on experience in an industrial mining environment while developing the skills required to advance in the electrical trade.<\/p>\n<h3><strong>Key Responsibilities<\/strong><\/h3>\n<ul>\n<li>\n<p>Assist journeyman electricians with installing, maintaining, and repairing industrial electrical systems and mining equipment<\/p>\n<\/li>\n<li>\n<p>Support troubleshooting efforts on motors, conveyors, crushers, pumps, lighting, and power distribution systems<\/p>\n<\/li>\n<li>\n<p>Perform basic electrical tasks under direct supervision, including conduit installation, wire pulling, terminations, and component replacement<\/p>\n<\/li>\n<li>\n<p>Use electrical meters and hand tools to perform testing and inspections as directed<\/p>\n<\/li>\n<li>\n<p>Follow lockout\/tagout procedures and all MSHA, NEC, and site-specific safety regulations<\/p>\n<\/li>\n<li>\n<p>Maintain a clean and organized work area and properly care for tools and equipment<\/p>\n<\/li>\n<li>\n<p>Assist with preventative maintenance activities to reduce equipment downtime<\/p>\n<\/li>\n<li>\n<p>Learn to read and interpret electrical schematics, drawings, and technical manuals<\/p>\n<\/li>\n<li>\n<p>Communicate job progress and equipment issues to supervising electricians<\/p>\n<\/li>\n<li>\n<p>Participate in safety meetings, training, and apprenticeship-related coursework as required<\/p>\n<\/li>\n<\/ul>\n<h3><strong>Required Qualifications<\/strong><\/h3>\n<ul>\n<li>\n<p>Enrollment in an electrical apprenticeship program (or equivalent on-the-job training experience)<\/p>\n<\/li>\n<li>\n<p>Basic understanding of electrical theory and safety practices<\/p>\n<\/li>\n<li>\n<p>Willingness to learn and take direction in a production-focused environment<\/p>\n<\/li>\n<li>\n<p>Ability to work safely in industrial and mining conditions<\/p>\n<\/li>\n<li>\n<p>Must be able to pass required site-specific training, medical exams, and drug\/alcohol screening<\/p>\n<\/li>\n<\/ul>\n<h3><strong>Tools &amp; Equipment Requirement<\/strong><\/h3>\n<ul>\n<li>\n<p><strong>Apprentices must furnish their own basic electrical hand tools and meters<\/strong>, appropriate for apprentice-level work<\/p>\n<\/li>\n<li>\n<p>Specialty tools, PPE, and site-specific equipment will be provided by the employer<\/p>\n<\/li>\n<\/ul>\n<h3><strong>Physical &amp; Work Environment<\/strong><\/h3>\n<ul>\n<li>\n<p>Work is performed in an active mining environment with exposure to dust, noise, vibration, and varying weather conditions<\/p>\n<\/li>\n<li>\n<p>Must be able to lift up to 50 lbs., climb ladders, and work in confined spaces or at heights<\/p>\n<\/li>\n<\/ul>\n<h3><strong>Preferred Qualifications<\/strong><\/h3>\n<ul>\n<li>\n<p>Previous industrial, construction, or mining experience<\/p>\n<\/li>\n<li>\n<p>MSHA certification or willingness to obtain<\/p>\n<\/li>\n<li>\n<p>Coursework completed toward an electrical apprenticeship<\/p>\n<\/li>\n<\/ul><p><\/p>","%category%":"","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/8e182d79e8b5-industrial-electrician-apprentice-mining","%breezy_id%":"8e182d79e8b5","%breezy_friendly_id%":"8e182d79e8b5-industrial-electrician-apprentice-mining","%breezy_created_date%":"2026-01-29T20:37:43.132Z","%breezy_updated_date%":"2026-01-29T20:39:34.449Z","%_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":3102,"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    Position Overview Turner Staffing Group is seeking an experienced Front End Loader Operator for a short-term contract assignment in Hurtsboro,&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":"Position Overview Turner Staffing Group is seeking an experienced Front End Loader Operator for a short-term contract assignment in Hurtsboro,&hellip;","address":"Hurtsboro, AL, USA","location":{"lat":"32.2418146","city":"Hurtsboro","state":"AL","country":"United States","lng":"-85.4163327","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/loader-operator\/","zoom":19,"extra_fields":{"post_excerpt":"Position Overview Turner Staffing Group is seeking an experienced Front End Loader Operator for a short-term contract assignment in Hurtsboro,&hellip;","post_content":"<h3>Position Overview<\/h3>\n<p>Turner Staffing Group is seeking an experienced <strong>Front End Loader Operator<\/strong> for a short-term contract assignment in <strong>Hurtsboro, Alabama<\/strong>. This role is ideal for a safety-focused operator with an <strong>active MSHA certification<\/strong> and proven experience operating front end loaders in a mining or aggregate environment.<\/p>\n<h3>Key Responsibilities<\/h3>\n<ul>\n<li>\n<p>Operate a front end loader safely and efficiently to move, load, and stockpile materials<\/p>\n<\/li>\n<li>\n<p>Perform daily equipment inspections and report any mechanical issues<\/p>\n<\/li>\n<li>\n<p>Follow all MSHA regulations, site safety rules, and company policies<\/p>\n<\/li>\n<li>\n<p>Work closely with site supervisors and crew members to support daily production goals<\/p>\n<\/li>\n<li>\n<p>Maintain a clean and organized work area<\/p>\n<\/li>\n<li>\n<p>Assist with other site tasks as needed<\/p>\n<\/li>\n<\/ul>\n<h3>Required Qualifications<\/h3>\n<ul>\n<li>\n<p><strong>Active MSHA certification (required)<\/strong><\/p>\n<\/li>\n<li>\n<p>Proven experience operating a front end loader<\/p>\n<\/li>\n<li>\n<p>Strong understanding of equipment safety and operational best practices<\/p>\n<\/li>\n<li>\n<p>Ability to work outdoors in varying weather conditions<\/p>\n<\/li>\n<li>\n<p>Reliable transportation to and from the job site<\/p>\n<\/li>\n<li>\n<p>Ability to commit to the full <strong>3\u20135 week contract<\/strong><\/p>\n<\/li>\n<\/ul>\n<h3>Preferred Qualifications<\/h3>\n<ul>\n<li>\n<p>Previous experience in mining, aggregate, or heavy industrial environments<\/p>\n<\/li>\n<li>\n<p>Mechanical awareness and basic equipment troubleshooting skills<\/p>\n<\/li>\n<\/ul>\n<h3>Why Work with Turner Staffing Group<\/h3>\n<ul>\n<li>\n<p>Competitive hourly pay<\/p>\n<\/li>\n<li>\n<p>Short-term contract with immediate impact<\/p>\n<\/li>\n<li>\n<p>Opportunity to work with a respected staffing partner in the heavy industry sector<\/p>\n<\/li>\n<\/ul>\n<p>Turner Staffing Group is an equal opportunity employer and values safety, reliability, and professionalism on every job site.<\/p>","post_title":"Loader Operator","post_link":"https:\/\/turnerstaffing.com\/position\/loader-operator\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Temporary","%experience%":"Associate","%location_country%":"United States","%location_city%":"Hurtsboro","%location_state_id%":"AL","%location_state_name%":"Alabama","%location_city_state%":"Hurtsboro, AL","%education%":"Unspecified","%department%":"","%description%":"<h3>Position Overview<\/h3>\n<p>Turner Staffing Group is seeking an experienced <strong>Front End Loader Operator<\/strong> for a short-term contract assignment in <strong>Hurtsboro, Alabama<\/strong>. This role is ideal for a safety-focused operator with an <strong>active MSHA certification<\/strong> and proven experience operating front end loaders in a mining or aggregate environment.<\/p>\n<h3>Key Responsibilities<\/h3>\n<ul>\n<li>\n<p>Operate a front end loader safely and efficiently to move, load, and stockpile materials<\/p>\n<\/li>\n<li>\n<p>Perform daily equipment inspections and report any mechanical issues<\/p>\n<\/li>\n<li>\n<p>Follow all MSHA regulations, site safety rules, and company policies<\/p>\n<\/li>\n<li>\n<p>Work closely with site supervisors and crew members to support daily production goals<\/p>\n<\/li>\n<li>\n<p>Maintain a clean and organized work area<\/p>\n<\/li>\n<li>\n<p>Assist with other site tasks as needed<\/p>\n<\/li>\n<\/ul>\n<h3>Required Qualifications<\/h3>\n<ul>\n<li>\n<p><strong>Active MSHA certification (required)<\/strong><\/p>\n<\/li>\n<li>\n<p>Proven experience operating a front end loader<\/p>\n<\/li>\n<li>\n<p>Strong understanding of equipment safety and operational best practices<\/p>\n<\/li>\n<li>\n<p>Ability to work outdoors in varying weather conditions<\/p>\n<\/li>\n<li>\n<p>Reliable transportation to and from the job site<\/p>\n<\/li>\n<li>\n<p>Ability to commit to the full <strong>3\u20135 week contract<\/strong><\/p>\n<\/li>\n<\/ul>\n<h3>Preferred Qualifications<\/h3>\n<ul>\n<li>\n<p>Previous experience in mining, aggregate, or heavy industrial environments<\/p>\n<\/li>\n<li>\n<p>Mechanical awareness and basic equipment troubleshooting skills<\/p>\n<\/li>\n<\/ul>\n<h3>Why Work with Turner Staffing Group<\/h3>\n<ul>\n<li>\n<p>Competitive hourly pay<\/p>\n<\/li>\n<li>\n<p>Short-term contract with immediate impact<\/p>\n<\/li>\n<li>\n<p>Opportunity to work with a respected staffing partner in the heavy industry sector<\/p>\n<\/li>\n<\/ul>\n<p>Turner Staffing Group is an equal opportunity employer and values safety, reliability, and professionalism on every job site.<\/p>","%category%":"Operations","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/9a2f1e5a8c71-loader-operator","%breezy_id%":"9a2f1e5a8c71","%breezy_friendly_id%":"9a2f1e5a8c71-loader-operator","%breezy_created_date%":"2026-01-29T16:42:09.546Z","%breezy_updated_date%":"2026-01-29T16:42:38.237Z","%_wpgmp_location_city%":"Hurtsboro","%_wpgmp_location_state%":"AL","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Hurtsboro, AL, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"32.2418146","%_wpgmp_metabox_longitude%":"-85.4163327","%rank_math_internal_links_processed%":"1"}},"id":3100,"infowindow_disable":false},{"source":"post","title":"Industrial Electrician &#8211; Mining","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Industrial Electrician &#8211; Mining\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Job Summary The Industrial Electrician is responsible for installing, maintaining, troubleshooting, and repairing electrical systems and equipment used in mining&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/industrial-electrician-mining\/\" name=\"Industrial Electrician &#8211; Mining\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Job Summary The Industrial Electrician is responsible for installing, maintaining, troubleshooting, and repairing electrical systems and equipment used in mining&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\/industrial-electrician-mining\/","zoom":19,"extra_fields":{"post_excerpt":"Job Summary The Industrial Electrician is responsible for installing, maintaining, troubleshooting, and repairing electrical systems and equipment used in mining&hellip;","post_content":"<h3><strong>Job Summary<\/strong><\/h3>\n<p>The Industrial Electrician is responsible for installing, maintaining, troubleshooting, and repairing electrical systems and equipment used in mining operations. This role supports safe, reliable production by ensuring all electrical components operate efficiently and in compliance with applicable safety regulations and standards.<\/p>\n<h3><strong>Key Responsibilities<\/strong><\/h3>\n<ul>\n<li>\n<p>Install, inspect, maintain, and repair industrial electrical systems, including power distribution, motors, MCCs, VFDs, PLCs, lighting systems, and instrumentation<\/p>\n<\/li>\n<li>\n<p>Troubleshoot electrical faults on mining equipment such as conveyors, crushers, pumps, drills, and processing plant equipment<\/p>\n<\/li>\n<li>\n<p>Perform preventative and corrective maintenance to minimize downtime<\/p>\n<\/li>\n<li>\n<p>Read and interpret electrical schematics, blueprints, and technical manuals<\/p>\n<\/li>\n<li>\n<p>Test electrical systems using appropriate meters and diagnostic tools<\/p>\n<\/li>\n<li>\n<p>Ensure all work complies with MSHA regulations, NEC standards, and site-specific safety policies<\/p>\n<\/li>\n<li>\n<p>Lockout\/tagout equipment and follow all safety and environmental procedures<\/p>\n<\/li>\n<li>\n<p>Communicate effectively with maintenance, operations, and supervision regarding equipment status and repairs<\/p>\n<\/li>\n<li>\n<p>Maintain accurate maintenance records and documentation<\/p>\n<\/li>\n<li>\n<p>Participate in safety meetings, inspections, and audits as required<\/p>\n<\/li>\n<\/ul>\n<h3><strong>Required Qualifications<\/strong><\/h3>\n<ul>\n<li>\n<p>Journeyman Electrician certification or equivalent industrial electrical experience<\/p>\n<\/li>\n<li>\n<p>Experience as an industrial electrician, preferably in a mining or heavy industrial environment<\/p>\n<\/li>\n<li>\n<p>Strong knowledge of AC\/DC systems, motor controls, and industrial electrical troubleshooting<\/p>\n<\/li>\n<li>\n<p>Ability to work independently in a fast-paced, production-driven environment<\/p>\n<\/li>\n<li>\n<p>Must be able to pass required site-specific training, medical exams, and drug\/alcohol screening<\/p>\n<\/li>\n<\/ul>\n<h3><strong>Tools &amp; Equipment Requirement<\/strong><\/h3>\n<ul>\n<li>\n<p><strong>Employees must furnish their own basic electrical hand tools and meters<\/strong>, including but not limited to multimeters, clamp meters, and standard electrician tools<\/p>\n<\/li>\n<li>\n<p>Specialty tools, PPE, and site-specific equipment will be provided by the employer<\/p>\n<\/li>\n<\/ul>\n<h3><strong>Physical &amp; Work Environment<\/strong><\/h3>\n<ul>\n<li>\n<p>Work is performed in an active mining environment with exposure to dust, noise, vibration, and varying weather conditions<\/p>\n<\/li>\n<li>\n<p>Must be able to lift up to 50 lbs., climb ladders, and work in confined spaces or at heights<\/p>\n<\/li>\n<\/ul>\n<h3><strong>Preferred Qualifications<\/strong><\/h3>\n<ul>\n<li>\n<p>MSHA certification<\/p>\n<\/li>\n<li>\n<p>Experience with PLC troubleshooting and VFDs<\/p>\n<\/li>\n<li>\n<p>Mining or aggregate industry experience<\/p><\/li><\/ul><p><\/p>","post_title":"Industrial Electrician &#8211; Mining","post_link":"https:\/\/turnerstaffing.com\/position\/industrial-electrician-mining\/","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%":"<h3><strong>Job Summary<\/strong><\/h3>\n<p>The Industrial Electrician is responsible for installing, maintaining, troubleshooting, and repairing electrical systems and equipment used in mining operations. This role supports safe, reliable production by ensuring all electrical components operate efficiently and in compliance with applicable safety regulations and standards.<\/p>\n<h3><strong>Key Responsibilities<\/strong><\/h3>\n<ul>\n<li>\n<p>Install, inspect, maintain, and repair industrial electrical systems, including power distribution, motors, MCCs, VFDs, PLCs, lighting systems, and instrumentation<\/p>\n<\/li>\n<li>\n<p>Troubleshoot electrical faults on mining equipment such as conveyors, crushers, pumps, drills, and processing plant equipment<\/p>\n<\/li>\n<li>\n<p>Perform preventative and corrective maintenance to minimize downtime<\/p>\n<\/li>\n<li>\n<p>Read and interpret electrical schematics, blueprints, and technical manuals<\/p>\n<\/li>\n<li>\n<p>Test electrical systems using appropriate meters and diagnostic tools<\/p>\n<\/li>\n<li>\n<p>Ensure all work complies with MSHA regulations, NEC standards, and site-specific safety policies<\/p>\n<\/li>\n<li>\n<p>Lockout\/tagout equipment and follow all safety and environmental procedures<\/p>\n<\/li>\n<li>\n<p>Communicate effectively with maintenance, operations, and supervision regarding equipment status and repairs<\/p>\n<\/li>\n<li>\n<p>Maintain accurate maintenance records and documentation<\/p>\n<\/li>\n<li>\n<p>Participate in safety meetings, inspections, and audits as required<\/p>\n<\/li>\n<\/ul>\n<h3><strong>Required Qualifications<\/strong><\/h3>\n<ul>\n<li>\n<p>Journeyman Electrician certification or equivalent industrial electrical experience<\/p>\n<\/li>\n<li>\n<p>Experience as an industrial electrician, preferably in a mining or heavy industrial environment<\/p>\n<\/li>\n<li>\n<p>Strong knowledge of AC\/DC systems, motor controls, and industrial electrical troubleshooting<\/p>\n<\/li>\n<li>\n<p>Ability to work independently in a fast-paced, production-driven environment<\/p>\n<\/li>\n<li>\n<p>Must be able to pass required site-specific training, medical exams, and drug\/alcohol screening<\/p>\n<\/li>\n<\/ul>\n<h3><strong>Tools &amp; Equipment Requirement<\/strong><\/h3>\n<ul>\n<li>\n<p><strong>Employees must furnish their own basic electrical hand tools and meters<\/strong>, including but not limited to multimeters, clamp meters, and standard electrician tools<\/p>\n<\/li>\n<li>\n<p>Specialty tools, PPE, and site-specific equipment will be provided by the employer<\/p>\n<\/li>\n<\/ul>\n<h3><strong>Physical &amp; Work Environment<\/strong><\/h3>\n<ul>\n<li>\n<p>Work is performed in an active mining environment with exposure to dust, noise, vibration, and varying weather conditions<\/p>\n<\/li>\n<li>\n<p>Must be able to lift up to 50 lbs., climb ladders, and work in confined spaces or at heights<\/p>\n<\/li>\n<\/ul>\n<h3><strong>Preferred Qualifications<\/strong><\/h3>\n<ul>\n<li>\n<p>MSHA certification<\/p>\n<\/li>\n<li>\n<p>Experience with PLC troubleshooting and VFDs<\/p>\n<\/li>\n<li>\n<p>Mining or aggregate industry experience<\/p><\/li><\/ul><p><\/p>","%category%":"","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/e0ad9dd5b6c6-industrial-electrician-mining","%breezy_id%":"e0ad9dd5b6c6","%breezy_friendly_id%":"e0ad9dd5b6c6-industrial-electrician-mining","%breezy_created_date%":"2026-01-29T20:30:02.554Z","%breezy_updated_date%":"2026-01-29T20:31:20.617Z","%_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":3101,"infowindow_disable":false},{"source":"post","title":"Working Crushing Foreman","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Working Crushing Foreman\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Turner Staffing Group is partnered with a large mining company in Kershaw, SC that is building&nbsp;out a new crushing crew&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/working-crushing-foreman\/\" name=\"Working Crushing Foreman\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Turner Staffing Group is partnered with a large mining company in Kershaw, SC that is building&nbsp;out a new crushing crew&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\/working-crushing-foreman\/","zoom":19,"extra_fields":{"post_excerpt":"Turner Staffing Group is partnered with a large mining company in Kershaw, SC that is building&nbsp;out a new crushing crew&hellip;","post_content":"<p>Turner Staffing Group is partnered with a large mining company in Kershaw, SC that is building&nbsp;out a new crushing crew and looking for a Working Crushing Foreman to lead the team.&nbsp;This role is hands-on \u2014 the successful candidate will not only supervise the crew but also&nbsp;operate equipment, oversee safe and efficient production, and perform basic crusher maintenance&nbsp;as needed.<br><br>Responsibilities:<br>-Lead and manage a crushing crew operating cone crushers.<br>-Operate heavy equipment when necessary to support production.<br>-Monitor crushing operations to ensure efficiency and safety standards are met.<br>-Perform and oversee routine\/basic maintenance on cone crushers.<br>-Train and mentor crew members to ensure safe and productive operations.<br>-Coordinate with site management to meet production goals and deadlines.<br><br>Qualifications:<br>-Proven experience working with cone crushers in a mining or quarry environment.<br>-Prior leadership or supervisory experience leading a production crew.<br>-Ability to operate heavy equipment as needed.<br>-Basic mechanical skills with crushers (troubleshooting and routine maintenance).<br>-Strong commitment to safety and team development.<br><br>Why Join:<br>-Opportunity to build and lead a new crushing crew.<br>-Competitive pay and benefits.<br>-Work with a respected mining company on a growing project<\/p>","post_title":"Working Crushing Foreman","post_link":"https:\/\/turnerstaffing.com\/position\/working-crushing-foreman\/","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>Turner Staffing Group is partnered with a large mining company in Kershaw, SC that is building&nbsp;out a new crushing crew and looking for a Working Crushing Foreman to lead the team.&nbsp;This role is hands-on \u2014 the successful candidate will not only supervise the crew but also&nbsp;operate equipment, oversee safe and efficient production, and perform basic crusher maintenance&nbsp;as needed.<br><br>Responsibilities:<br>-Lead and manage a crushing crew operating cone crushers.<br>-Operate heavy equipment when necessary to support production.<br>-Monitor crushing operations to ensure efficiency and safety standards are met.<br>-Perform and oversee routine\/basic maintenance on cone crushers.<br>-Train and mentor crew members to ensure safe and productive operations.<br>-Coordinate with site management to meet production goals and deadlines.<br><br>Qualifications:<br>-Proven experience working with cone crushers in a mining or quarry environment.<br>-Prior leadership or supervisory experience leading a production crew.<br>-Ability to operate heavy equipment as needed.<br>-Basic mechanical skills with crushers (troubleshooting and routine maintenance).<br>-Strong commitment to safety and team development.<br><br>Why Join:<br>-Opportunity to build and lead a new crushing crew.<br>-Competitive pay and benefits.<br>-Work with a respected mining company on a growing project<\/p>","%category%":"","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/1e96727536b9-working-crushing-foreman","%breezy_id%":"1e96727536b9","%breezy_friendly_id%":"1e96727536b9-working-crushing-foreman","%breezy_created_date%":"2025-09-17T16:24:32.839Z","%breezy_updated_date%":"2026-01-28T20:49:06.120Z","%_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":3099,"infowindow_disable":false},{"source":"post","title":"Business Assistant","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Business Assistant\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Turner Staffing Group is seeking a dependable Business Assistant to support administrative and data entry activities for a client project&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/business-assistant-2\/\" name=\"Business Assistant\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Turner Staffing Group is seeking a dependable Business Assistant to support administrative and data entry activities for a client project&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\/business-assistant-2\/","zoom":19,"extra_fields":{"post_excerpt":"Turner Staffing Group is seeking a dependable Business Assistant to support administrative and data entry activities for a client project&hellip;","post_content":"<p>Turner Staffing Group is seeking a dependable <strong>Business Assistant<\/strong> to support administrative and data entry activities for a client project at an <strong>active mine site<\/strong> in the <strong>Elko, Nevada<\/strong> area. This is an <strong>onsite, project-based <\/strong>(90 days)<strong> role<\/strong> ideal for candidates with strong attention to detail and basic computer skills who are comfortable working in an industrial environment.<\/p><p><strong><strong>Position Overview<\/strong><\/strong><\/p><p>The Business Assistant will provide administrative and clerical support focused on data entry, document management, and system updates. This role plays a key part in ensuring accurate recordkeeping and smooth day-to-day administrative operations during a short-term project.<\/p><p><strong><strong>Key Responsibilities<\/strong><\/strong><\/p><ul><li><p>Perform <strong>data entry<\/strong> with a high level of accuracy<\/p><\/li><li><p>Scan, organize, and maintain digital and physical documents<\/p><\/li><li><p>Enter and update information in <strong>SAP<\/strong> and other internal systems (training may be provided)<\/p><\/li><li><p>Support administrative workflows and reporting needs<\/p><\/li><li><p>Maintain organized files and records<\/p><\/li><li><p>Follow all site safety, health, and environmental procedures<\/p><\/li><li><p>Perform other administrative duties as assigned<\/p><\/li><\/ul><p><strong><strong>Required Qualifications<\/strong><\/strong><\/p><ul><li><p>Basic computer skills, including familiarity with common office software<\/p><\/li><li><p>Strong attention to detail and organizational skills<\/p><\/li><li><p>Ability to work onsite at a mine site<\/p><\/li><li><p>Reliable and able to work <strong>Monday&ndash;Thursday, 10-hour shifts<\/strong><\/p><\/li><li><p>Must be authorized to work in the U.S. without visa sponsorship<\/p><\/li><li><p>Local candidates only<\/p><\/li><\/ul><p><strong><strong>Preferred Qualifications<\/strong><\/strong><\/p><ul><li><p>Prior experience with <strong>SAP<\/strong><\/p><\/li><li><p>Previous administrative, clerical, or data entry experience<\/p><\/li><li><p>Experience working in industrial or site-based environments<\/p><\/li><\/ul><p><strong><strong>Why Work With Turner Staffing Group<\/strong><\/strong><\/p><ul><li><p>Short-term project with a predictable schedule<\/p><\/li><li><p>Opportunity to gain exposure to site-based administrative operations<\/p><\/li><li><p>Work with a staffing partner experienced in mining and industrial projects<\/p><\/li><li><p>Competitive pay for a project-based assignment<\/p><\/li><\/ul><p><strong><strong>Apply Today<\/strong><\/strong><\/p><p>If you are detail-oriented, organized, and available for a short-term onsite assignment in the Elko area, we encourage you to apply.<\/p><p><strong>Turner Staffing Group is an equal opportunity employer.<\/strong><\/p>","post_title":"Business Assistant","post_link":"https:\/\/turnerstaffing.com\/position\/business-assistant-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 seeking a dependable <strong>Business Assistant<\/strong> to support administrative and data entry activities for a client project at an <strong>active mine site<\/strong> in the <strong>Elko, Nevada<\/strong> area. This is an <strong>onsite, project-based <\/strong>(90 days)<strong> role<\/strong> ideal for candidates with strong attention to detail and basic computer skills who are comfortable working in an industrial environment.<\/p><p><strong><strong>Position Overview<\/strong><\/strong><\/p><p>The Business Assistant will provide administrative and clerical support focused on data entry, document management, and system updates. This role plays a key part in ensuring accurate recordkeeping and smooth day-to-day administrative operations during a short-term project.<\/p><p><strong><strong>Key Responsibilities<\/strong><\/strong><\/p><ul><li><p>Perform <strong>data entry<\/strong> with a high level of accuracy<\/p><\/li><li><p>Scan, organize, and maintain digital and physical documents<\/p><\/li><li><p>Enter and update information in <strong>SAP<\/strong> and other internal systems (training may be provided)<\/p><\/li><li><p>Support administrative workflows and reporting needs<\/p><\/li><li><p>Maintain organized files and records<\/p><\/li><li><p>Follow all site safety, health, and environmental procedures<\/p><\/li><li><p>Perform other administrative duties as assigned<\/p><\/li><\/ul><p><strong><strong>Required Qualifications<\/strong><\/strong><\/p><ul><li><p>Basic computer skills, including familiarity with common office software<\/p><\/li><li><p>Strong attention to detail and organizational skills<\/p><\/li><li><p>Ability to work onsite at a mine site<\/p><\/li><li><p>Reliable and able to work <strong>Monday&ndash;Thursday, 10-hour shifts<\/strong><\/p><\/li><li><p>Must be authorized to work in the U.S. without visa sponsorship<\/p><\/li><li><p>Local candidates only<\/p><\/li><\/ul><p><strong><strong>Preferred Qualifications<\/strong><\/strong><\/p><ul><li><p>Prior experience with <strong>SAP<\/strong><\/p><\/li><li><p>Previous administrative, clerical, or data entry experience<\/p><\/li><li><p>Experience working in industrial or site-based environments<\/p><\/li><\/ul><p><strong><strong>Why Work With Turner Staffing Group<\/strong><\/strong><\/p><ul><li><p>Short-term project with a predictable schedule<\/p><\/li><li><p>Opportunity to gain exposure to site-based administrative operations<\/p><\/li><li><p>Work with a staffing partner experienced in mining and industrial projects<\/p><\/li><li><p>Competitive pay for a project-based assignment<\/p><\/li><\/ul><p><strong><strong>Apply Today<\/strong><\/strong><\/p><p>If you are detail-oriented, organized, and available for a short-term onsite assignment in the Elko area, we encourage you to apply.<\/p><p><strong>Turner Staffing Group is an equal opportunity employer.<\/strong><\/p>","%application_url%":"https:\/\/jobs.crelate.com\/portal\/turnerstaffinggroup\/job\/g45csizx8oku4oatyyjz31cw8o","%crelate_id%":"g45csizx8oku4oatyyjz31cw8o","%crelate_created_date%":"2026-01-27T23:08:11.49Z","%crelate_updated_date%":"2026-02-01T13:52:09.15Z","%_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":3098,"infowindow_disable":false},{"source":"post","title":"Business Assistant","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Business Assistant\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Turner Staffing Group is seeking a dependable&nbsp;Business Assistant&nbsp;to support administrative and data entry activities for a client project at an&nbsp;active&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/business-assistant\/\" name=\"Business Assistant\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Turner Staffing Group is seeking a dependable&nbsp;Business Assistant&nbsp;to support administrative and data entry activities for a client project at an&nbsp;active&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\/business-assistant\/","zoom":19,"extra_fields":{"post_excerpt":"Turner Staffing Group is seeking a dependable&nbsp;Business Assistant&nbsp;to support administrative and data entry activities for a client project at an&nbsp;active&hellip;","post_content":"<p>Turner Staffing Group is seeking a dependable&nbsp;<strong>Business Assistant<\/strong>&nbsp;to support administrative and data entry activities for a client project at an&nbsp;<strong>active mine site<\/strong>&nbsp;in the&nbsp;<strong>Elko, Nevada<\/strong>&nbsp;area. This is an&nbsp;<strong>onsite, project-based&nbsp;<\/strong>(90 days)<strong>&nbsp;role<\/strong>&nbsp;ideal for candidates with strong attention to detail and basic computer skills who are comfortable working in an industrial environment.<\/p>\n<p><strong><strong>Position Overview<\/strong><\/strong><\/p>\n<p>The Business Assistant will provide administrative and clerical support focused on data entry, document management, and system updates. This role plays a key part in ensuring accurate recordkeeping and smooth day-to-day administrative operations during a short-term project.<\/p>\n<p><strong><strong>Key Responsibilities<\/strong><\/strong><\/p>\n<ul><li>Perform&nbsp;<strong>data entry<\/strong>&nbsp;with a high level of accuracy<\/li><li>Scan, organize, and maintain digital and physical documents<\/li><li>Enter and update information in&nbsp;<strong>SAP<\/strong>&nbsp;and other internal systems (training may be provided)<\/li><li>Support administrative workflows and reporting needs<\/li><li>Maintain organized files and records<\/li><li>Follow all site safety, health, and environmental procedures<\/li><li>Perform other administrative duties as assigned<\/li><\/ul>\n<p><strong><strong>Required Qualifications<\/strong><\/strong><\/p>\n<ul><li>Basic computer skills, including familiarity with common office software<\/li><li>Strong attention to detail and organizational skills<\/li><li>Ability to work onsite at a mine site<\/li><li>Reliable and able to work&nbsp;<strong>Monday\u2013Thursday, 10-hour shifts<\/strong><\/li><li>Must be authorized to work in the U.S. without visa sponsorship<\/li><li>Local candidates only<\/li><\/ul>\n<p><strong><strong>Preferred Qualifications<\/strong><\/strong><\/p>\n<ul><li>Prior experience with&nbsp;<strong>SAP<\/strong><\/li><li>Previous administrative, clerical, or data entry experience<\/li><li>Experience working in industrial or site-based environments<\/li><\/ul>\n<p><strong><strong>Why Work With Turner Staffing Group<\/strong><\/strong><\/p>\n<ul><li>Short-term project with a predictable schedule<\/li><li>Opportunity to gain exposure to site-based administrative operations<\/li><li>Work with a staffing partner experienced in mining and industrial projects<\/li><li>Competitive pay for a project-based assignment<\/li><\/ul>\n<p><strong><strong>Apply Today<\/strong><\/strong><\/p>\n<p>If you are detail-oriented, organized, and available for a short-term onsite assignment in the Elko area, we encourage you to apply.<\/p>\n<p><strong>Turner Staffing Group is an equal opportunity employer.<\/strong><\/p>","post_title":"Business Assistant","post_link":"https:\/\/turnerstaffing.com\/position\/business-assistant\/","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 seeking a dependable&nbsp;<strong>Business Assistant<\/strong>&nbsp;to support administrative and data entry activities for a client project at an&nbsp;<strong>active mine site<\/strong>&nbsp;in the&nbsp;<strong>Elko, Nevada<\/strong>&nbsp;area. This is an&nbsp;<strong>onsite, project-based&nbsp;<\/strong>(90 days)<strong>&nbsp;role<\/strong>&nbsp;ideal for candidates with strong attention to detail and basic computer skills who are comfortable working in an industrial environment.<\/p>\n<p><strong><strong>Position Overview<\/strong><\/strong><\/p>\n<p>The Business Assistant will provide administrative and clerical support focused on data entry, document management, and system updates. This role plays a key part in ensuring accurate recordkeeping and smooth day-to-day administrative operations during a short-term project.<\/p>\n<p><strong><strong>Key Responsibilities<\/strong><\/strong><\/p>\n<ul><li>Perform&nbsp;<strong>data entry<\/strong>&nbsp;with a high level of accuracy<\/li><li>Scan, organize, and maintain digital and physical documents<\/li><li>Enter and update information in&nbsp;<strong>SAP<\/strong>&nbsp;and other internal systems (training may be provided)<\/li><li>Support administrative workflows and reporting needs<\/li><li>Maintain organized files and records<\/li><li>Follow all site safety, health, and environmental procedures<\/li><li>Perform other administrative duties as assigned<\/li><\/ul>\n<p><strong><strong>Required Qualifications<\/strong><\/strong><\/p>\n<ul><li>Basic computer skills, including familiarity with common office software<\/li><li>Strong attention to detail and organizational skills<\/li><li>Ability to work onsite at a mine site<\/li><li>Reliable and able to work&nbsp;<strong>Monday\u2013Thursday, 10-hour shifts<\/strong><\/li><li>Must be authorized to work in the U.S. without visa sponsorship<\/li><li>Local candidates only<\/li><\/ul>\n<p><strong><strong>Preferred Qualifications<\/strong><\/strong><\/p>\n<ul><li>Prior experience with&nbsp;<strong>SAP<\/strong><\/li><li>Previous administrative, clerical, or data entry experience<\/li><li>Experience working in industrial or site-based environments<\/li><\/ul>\n<p><strong><strong>Why Work With Turner Staffing Group<\/strong><\/strong><\/p>\n<ul><li>Short-term project with a predictable schedule<\/li><li>Opportunity to gain exposure to site-based administrative operations<\/li><li>Work with a staffing partner experienced in mining and industrial projects<\/li><li>Competitive pay for a project-based assignment<\/li><\/ul>\n<p><strong><strong>Apply Today<\/strong><\/strong><\/p>\n<p>If you are detail-oriented, organized, and available for a short-term onsite assignment in the Elko area, we encourage you to apply.<\/p>\n<p><strong>Turner Staffing Group is an equal opportunity employer.<\/strong><\/p>","%category%":"","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/2680a0d23a00-business-assistant","%breezy_id%":"2680a0d23a00","%breezy_friendly_id%":"2680a0d23a00-business-assistant","%breezy_created_date%":"2026-01-27T23:01:51.418Z","%breezy_updated_date%":"2026-01-27T23:08:59.783Z","%_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":3097,"infowindow_disable":false},{"source":"post","title":"Senior Project Manager","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Senior Project Manager\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Project Manager \u2013 Civil Construction Location: Tampa, FL Work Schedule: 100% in-office | Monday\u2013Friday Overview Our client is&nbsp;seeking an experienced&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/senior-project-manager-2\/\" name=\"Senior Project Manager\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Project Manager \u2013 Civil Construction Location: Tampa, FL Work Schedule: 100% in-office | Monday\u2013Friday Overview Our client is&nbsp;seeking an experienced&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-2\/","zoom":19,"extra_fields":{"post_excerpt":"Project Manager \u2013 Civil Construction Location: Tampa, FL Work Schedule: 100% in-office | Monday\u2013Friday Overview Our client is&nbsp;seeking an experienced&hellip;","post_content":"<h2>Project Manager \u2013 Civil Construction<\/h2>\n<p><strong>Location:<\/strong> Tampa, FL<br>\n<strong>Work Schedule:<\/strong> 100% in-office | Monday\u2013Friday<\/p>\n<h3>Overview<\/h3>\n<p>Our client is&nbsp;seeking an experienced Civil Project Manager to lead complex private-sector construction projects across commercial and residential markets. This role is responsible for managing multiple concurrent projects, overseeing field and office coordination, and driving projects to successful completion with a strong focus on safety, quality, schedule, and profitability.<\/p>\n<p>This position reports directly to the Vice President of Private Works and plays a critical leadership role within the organization, managing an Assistant Project Manager and a Project Engineer.<\/p>\n<h3><strong>Why Join Us<\/strong><\/h3>\n<p>We offer a high-performance, team-oriented environment with significant upside for motivated leaders:<\/p>\n<ul>\n<li>\n<p>Fast-paced, collaborative, and inclusive culture<\/p>\n<\/li>\n<li>\n<p>Quarterly bonus structure tied to performance<\/p>\n<\/li>\n<li>\n<p>401(k) with 6% full company match<\/p>\n<\/li>\n<li>\n<p>Competitive benefits package<\/p><\/li><li><p>On-site fitness and recreation available to employees<\/p><\/li>\n<li>\n<p>Clear runway for growth and long-term career development<\/p>\n<\/li>\n<\/ul>\n<h3><strong>Key Responsibilities<\/strong><\/h3>\n<p>As a Project Manager, you will be responsible for $20\u201325MM in annual project volume, managing 7\u201310 projects simultaneously, including:<\/p>\n<ul>\n<li>\n<p>Developing and executing comprehensive project plans, including schedules, staffing plans, procurement strategies, and cost controls<\/p>\n<\/li>\n<li>\n<p>Managing all phases of civil construction projects, including:<\/p>\n<ul>\n<li>\n<p>Site work and earthwork<\/p>\n<\/li>\n<li>\n<p>Mass excavation<\/p>\n<\/li>\n<li>\n<p>Land clearing<\/p>\n<\/li>\n<li>\n<p>Wet utilities and underground infrastructure<\/p>\n<\/li>\n<\/ul>\n<\/li>\n<li>\n<p>Coordinating subcontractors, vendors, field leadership, and internal teams to ensure alignment with project objectives<\/p>\n<\/li>\n<li>\n<p>Evaluating and selecting subcontractors based on scope, qualifications, safety performance, and cost effectiveness<\/p>\n<\/li>\n<li>\n<p>Monitoring job cost reports, production rates, KPIs, and overall financial performance<\/p>\n<\/li>\n<li>\n<p>Ensuring strict compliance with safety standards, local codes, and regulatory requirements<\/p>\n<\/li>\n<li>\n<p>Leading project meetings, progress reviews, and issue-resolution discussions<\/p>\n<\/li>\n<li>\n<p>Managing project documentation including contracts, change orders, drawings, permits, and closeout materials<\/p>\n<\/li>\n<li>\n<p>Providing clear and consistent communication to internal leadership regarding schedule, budget, risks, and milestones<\/p>\n<\/li>\n<li>\n<p>Identifying improvement opportunities and implementing corrective actions to enhance execution and profitability<\/p>\n<\/li>\n<\/ul>\n<h3><strong>What We\u2019re Looking For<\/strong><\/h3>\n<p>To succeed in this role, you should bring:<\/p>\n<ul>\n<li>\n<p>5+ years of experience in civil construction project management<\/p>\n<\/li>\n<li>\n<p>Proven experience managing multiple active projects and large annual revenue volumes<\/p>\n<\/li>\n<li>\n<p>Strong understanding of private-sector civil work (commercial subcontracted work and residential prime contracts)<\/p>\n<\/li>\n<li>\n<p>Highly organized, proactive, and collaborative leadership style<\/p>\n<\/li>\n<li>\n<p>Strong communication skills with the ability to lead teams and interface with executives, owners, and trade partners<\/p>\n<\/li>\n<li>\n<p>Proficiency with construction software and reporting tools, including:<\/p>\n<ul>\n<li>\n<p>HCSS HeavyJob (required)<\/p>\n<\/li>\n<li>\n<p>Microsoft Office (intermediate level or higher)<\/p>\n<\/li>\n<\/ul>\n<\/li>\n<li>\n<p>A continuous-learning mindset with a willingness to mentor and develop junior staff<\/p>\n<\/li>\n<\/ul>\n<h3><strong>Preferred Qualifications<\/strong><\/h3>\n<ul>\n<li>\n<p>Bachelor\u2019s degree in Construction Management, Civil Engineering, or a related field<\/p>\n<\/li>\n<li>\n<p>Experience working in fast-growth or high-production civil environments<\/p>\n<\/li>\n<\/ul>\n<h3><strong>Additional Details<\/strong><\/h3>\n<ul>\n<li>\n<p>Fully in-office role based in Tampa, FL<\/p>\n<\/li>\n<li>\n<p>Relocation assistance may be available for qualified candidates<\/p>\n<\/li>\n<li>\n<p>Ideal candidates will have experience in Florida or the broader Southeast region<\/p><\/li><\/ul>","post_title":"Senior Project Manager","post_link":"https:\/\/turnerstaffing.com\/position\/senior-project-manager-2\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"","%location_country%":"United States","%location_city%":"Tampa","%location_state_id%":"FL","%location_state_name%":"Florida","%location_city_state%":"Tampa, FL","%education%":"","%department%":"","%description%":"<h2>Project Manager \u2013 Civil Construction<\/h2>\n<p><strong>Location:<\/strong> Tampa, FL<br>\n<strong>Work Schedule:<\/strong> 100% in-office | Monday\u2013Friday<\/p>\n<h3>Overview<\/h3>\n<p>Our client is&nbsp;seeking an experienced Civil Project Manager to lead complex private-sector construction projects across commercial and residential markets. This role is responsible for managing multiple concurrent projects, overseeing field and office coordination, and driving projects to successful completion with a strong focus on safety, quality, schedule, and profitability.<\/p>\n<p>This position reports directly to the Vice President of Private Works and plays a critical leadership role within the organization, managing an Assistant Project Manager and a Project Engineer.<\/p>\n<h3><strong>Why Join Us<\/strong><\/h3>\n<p>We offer a high-performance, team-oriented environment with significant upside for motivated leaders:<\/p>\n<ul>\n<li>\n<p>Fast-paced, collaborative, and inclusive culture<\/p>\n<\/li>\n<li>\n<p>Quarterly bonus structure tied to performance<\/p>\n<\/li>\n<li>\n<p>401(k) with 6% full company match<\/p>\n<\/li>\n<li>\n<p>Competitive benefits package<\/p><\/li><li><p>On-site fitness and recreation available to employees<\/p><\/li>\n<li>\n<p>Clear runway for growth and long-term career development<\/p>\n<\/li>\n<\/ul>\n<h3><strong>Key Responsibilities<\/strong><\/h3>\n<p>As a Project Manager, you will be responsible for $20\u201325MM in annual project volume, managing 7\u201310 projects simultaneously, including:<\/p>\n<ul>\n<li>\n<p>Developing and executing comprehensive project plans, including schedules, staffing plans, procurement strategies, and cost controls<\/p>\n<\/li>\n<li>\n<p>Managing all phases of civil construction projects, including:<\/p>\n<ul>\n<li>\n<p>Site work and earthwork<\/p>\n<\/li>\n<li>\n<p>Mass excavation<\/p>\n<\/li>\n<li>\n<p>Land clearing<\/p>\n<\/li>\n<li>\n<p>Wet utilities and underground infrastructure<\/p>\n<\/li>\n<\/ul>\n<\/li>\n<li>\n<p>Coordinating subcontractors, vendors, field leadership, and internal teams to ensure alignment with project objectives<\/p>\n<\/li>\n<li>\n<p>Evaluating and selecting subcontractors based on scope, qualifications, safety performance, and cost effectiveness<\/p>\n<\/li>\n<li>\n<p>Monitoring job cost reports, production rates, KPIs, and overall financial performance<\/p>\n<\/li>\n<li>\n<p>Ensuring strict compliance with safety standards, local codes, and regulatory requirements<\/p>\n<\/li>\n<li>\n<p>Leading project meetings, progress reviews, and issue-resolution discussions<\/p>\n<\/li>\n<li>\n<p>Managing project documentation including contracts, change orders, drawings, permits, and closeout materials<\/p>\n<\/li>\n<li>\n<p>Providing clear and consistent communication to internal leadership regarding schedule, budget, risks, and milestones<\/p>\n<\/li>\n<li>\n<p>Identifying improvement opportunities and implementing corrective actions to enhance execution and profitability<\/p>\n<\/li>\n<\/ul>\n<h3><strong>What We\u2019re Looking For<\/strong><\/h3>\n<p>To succeed in this role, you should bring:<\/p>\n<ul>\n<li>\n<p>5+ years of experience in civil construction project management<\/p>\n<\/li>\n<li>\n<p>Proven experience managing multiple active projects and large annual revenue volumes<\/p>\n<\/li>\n<li>\n<p>Strong understanding of private-sector civil work (commercial subcontracted work and residential prime contracts)<\/p>\n<\/li>\n<li>\n<p>Highly organized, proactive, and collaborative leadership style<\/p>\n<\/li>\n<li>\n<p>Strong communication skills with the ability to lead teams and interface with executives, owners, and trade partners<\/p>\n<\/li>\n<li>\n<p>Proficiency with construction software and reporting tools, including:<\/p>\n<ul>\n<li>\n<p>HCSS HeavyJob (required)<\/p>\n<\/li>\n<li>\n<p>Microsoft Office (intermediate level or higher)<\/p>\n<\/li>\n<\/ul>\n<\/li>\n<li>\n<p>A continuous-learning mindset with a willingness to mentor and develop junior staff<\/p>\n<\/li>\n<\/ul>\n<h3><strong>Preferred Qualifications<\/strong><\/h3>\n<ul>\n<li>\n<p>Bachelor\u2019s degree in Construction Management, Civil Engineering, or a related field<\/p>\n<\/li>\n<li>\n<p>Experience working in fast-growth or high-production civil environments<\/p>\n<\/li>\n<\/ul>\n<h3><strong>Additional Details<\/strong><\/h3>\n<ul>\n<li>\n<p>Fully in-office role based in Tampa, FL<\/p>\n<\/li>\n<li>\n<p>Relocation assistance may be available for qualified candidates<\/p>\n<\/li>\n<li>\n<p>Ideal candidates will have experience in Florida or the broader Southeast region<\/p><\/li><\/ul>","%category%":"Operations","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/8f2429b71739-senior-project-manager","%breezy_id%":"8f2429b71739","%breezy_friendly_id%":"8f2429b71739-senior-project-manager","%breezy_created_date%":"2026-01-27T14:15:24.744Z","%breezy_updated_date%":"2026-01-27T14:16:07.229Z","%_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":3095,"infowindow_disable":false},{"source":"post","title":"Drill Operator","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Drill Operator\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Job Title: Drill Operator Location:&nbsp;Ely, NV Company:&nbsp;Turner Mining Group Position Type:&nbsp;Full-Time Salary:&nbsp;Competitive, based on experience Job Overview: Turner Mining&nbsp;Group is&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/drill-operator\/\" name=\"Drill Operator\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Job Title: Drill Operator Location:&nbsp;Ely, NV Company:&nbsp;Turner Mining Group Position Type:&nbsp;Full-Time Salary:&nbsp;Competitive, based on experience Job Overview: Turner Mining&nbsp;Group is&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\/drill-operator\/","zoom":19,"extra_fields":{"post_excerpt":"Job Title: Drill Operator Location:&nbsp;Ely, NV Company:&nbsp;Turner Mining Group Position Type:&nbsp;Full-Time Salary:&nbsp;Competitive, based on experience Job Overview: Turner Mining&nbsp;Group is&hellip;","post_content":"<h3><strong>Job Title: Drill Operator<\/strong><\/h3>\n<p><strong>Location:<\/strong>&nbsp;Ely, NV<\/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 Ely, NV. 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>\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":"Drill Operator","post_link":"https:\/\/turnerstaffing.com\/position\/drill-operator\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Associate","%location_country%":"United States","%location_city%":"Ely","%location_state_id%":"NV","%location_state_name%":"Nevada","%location_city_state%":"Ely, NV","%education%":"Unspecified","%department%":"","%description%":"<h3><strong>Job Title: Drill Operator<\/strong><\/h3>\n<p><strong>Location:<\/strong>&nbsp;Ely, NV<\/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 Ely, NV. 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>\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\/4a645a75513e-drill-operator","%breezy_id%":"4a645a75513e","%breezy_friendly_id%":"4a645a75513e-drill-operator","%breezy_created_date%":"2026-01-27T15:44:56.934Z","%breezy_updated_date%":"2026-01-27T15:45:16.451Z","%_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":3096,"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 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\/","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\/dfksa1mbzx3jq4o1iaxcsxtsqh","%crelate_id%":"dfksa1mbzx3jq4o1iaxcsxtsqh","%crelate_created_date%":"2025-11-18T13:48:47.83Z","%crelate_updated_date%":"2026-01-30T13:00:49.54Z","%_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":3092,"infowindow_disable":false},{"source":"post","title":"AP Clerk","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    AP Clerk\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Key Responsibilities The Accounts Payable Clerk ensures accurate and timely processing of vendor invoices, expense reports, and other financial transactions.&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/ap-clerk-2\/\" name=\"AP Clerk\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Key Responsibilities The Accounts Payable Clerk ensures accurate and timely processing of vendor invoices, expense reports, and other financial transactions.&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\/ap-clerk-2\/","zoom":19,"extra_fields":{"post_excerpt":"Key Responsibilities The Accounts Payable Clerk ensures accurate and timely processing of vendor invoices, expense reports, and other financial transactions.&hellip;","post_content":"<p><strong>Key Responsibilities<\/strong><\/p><p>The Accounts Payable Clerk ensures accurate and timely processing of vendor invoices, expense reports, and other financial transactions. The ideal candidate will have strong attention to detail, excellent organizational skills, and the ability to work collaboratively in a dynamic environment. Skillfully handle the processing and verification of invoices specific to gold mine operations. Ensure adherence to company policies and procedures. Engage in effective communication with vendors, resolving any invoicing discrepancies promptly. Foster positive relationships with key suppliers to enhance collaboration. Code and categorize expenses meticulously, contributing to effective tracking and reporting. Collaborate closely with project managers to understand the unique financial dynamics of gold mine projects. Provide invaluable support in budget tracking and financial analysis. Leverage your expertise in SAP, MS Excel, and AP software to enhance efficiency in financial processes. Actively contribute to the implementation and improvement of financial systems.<\/p><p><strong>Essential Skills &amp; Knowledge<\/strong><\/p><ul><li>Proven experience in accounts payable or a related field, with a minimum of [X years].<\/li><li>Proficient in SAP, MS Excel, and other AP software.<\/li><li>Exceptional attention to detail and accuracy in data entry.<\/li><li>Strong communication and interpersonal skills.<\/li><li>Ability to work both independently and collaboratively within a team.<\/li><li>Understanding of project-based accounting principles is a significant advantage.<\/li><\/ul><ul><li>Bachelor's degree in Accounting, Finance, or a related field preferred.<\/li><\/ul><ul><li>Strong organizational and interpersonal skills, with a knack for continuously improving processes and outcomes.<\/li><li>Organized, proactive problem solver and solution developer, capable of working closely with business executives.<\/li><\/ul><p><strong><span style=\"color:#444444\">Benefits<\/span><\/strong><span style=\"color:#444444\"><br \/><\/span><\/p><p><span style=\"color:#444444\">Turner Staffing Group's client offers a competitive salary, an excellent work culture, career advancement opportunities. Turner Staffing Group's client offers a benefits program which includes Medical, Dental, Vision, Life, and a 401k with company match. Turner Staffing Group's client believes in a work life balance and established paid vacation time off policy as well as paid time off for major holidays.<\/span><\/p><p><span style=\"color:#444444\">We encourage and celebrate an inclusive environment for all employees and are proud to be an equal opportunity workplace and affirmative action employer.<\/span><br \/><\/p>  ","post_title":"AP Clerk","post_link":"https:\/\/turnerstaffing.com\/position\/ap-clerk-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><strong>Key Responsibilities<\/strong><\/p><p>The Accounts Payable Clerk ensures accurate and timely processing of vendor invoices, expense reports, and other financial transactions. The ideal candidate will have strong attention to detail, excellent organizational skills, and the ability to work collaboratively in a dynamic environment. Skillfully handle the processing and verification of invoices specific to gold mine operations. Ensure adherence to company policies and procedures. Engage in effective communication with vendors, resolving any invoicing discrepancies promptly. Foster positive relationships with key suppliers to enhance collaboration. Code and categorize expenses meticulously, contributing to effective tracking and reporting. Collaborate closely with project managers to understand the unique financial dynamics of gold mine projects. Provide invaluable support in budget tracking and financial analysis. Leverage your expertise in SAP, MS Excel, and AP software to enhance efficiency in financial processes. Actively contribute to the implementation and improvement of financial systems.<\/p><p><strong>Essential Skills &amp; Knowledge<\/strong><\/p><ul><li>Proven experience in accounts payable or a related field, with a minimum of [X years].<\/li><li>Proficient in SAP, MS Excel, and other AP software.<\/li><li>Exceptional attention to detail and accuracy in data entry.<\/li><li>Strong communication and interpersonal skills.<\/li><li>Ability to work both independently and collaboratively within a team.<\/li><li>Understanding of project-based accounting principles is a significant advantage.<\/li><\/ul><ul><li>Bachelor's degree in Accounting, Finance, or a related field preferred.<\/li><\/ul><ul><li>Strong organizational and interpersonal skills, with a knack for continuously improving processes and outcomes.<\/li><li>Organized, proactive problem solver and solution developer, capable of working closely with business executives.<\/li><\/ul><p><strong><span style=\"color:#444444;\">Benefits<\/span><\/strong><span style=\"color:#444444;\"><br \/><\/span><\/p><p><span style=\"color:#444444;\">Turner Staffing Group's client offers a competitive salary, an excellent work culture, career advancement opportunities. Turner Staffing Group's client offers a benefits program which includes Medical, Dental, Vision, Life, and a 401k with company match. Turner Staffing Group's client believes in a work life balance and established paid vacation time off policy as well as paid time off for major holidays.<\/span><\/p><p><span style=\"color:#444444;\">We encourage and celebrate an inclusive environment for all employees and are proud to be an equal opportunity workplace and affirmative action employer.<\/span><br \/><\/p>  ","%application_url%":"https:\/\/jobs.crelate.com\/portal\/turnerstaffinggroup\/job\/yp7b6as8p7fkss11moq7sno6se","%crelate_id%":"yp7b6as8p7fkss11moq7sno6se","%crelate_created_date%":"2026-01-20T18:41:15.6Z","%crelate_updated_date%":"2026-02-04T00:00:26.94Z","%_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":3093,"infowindow_disable":false},{"source":"post","title":"Electrical Designer","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Electrical Designer\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Responsibilities Create, duplicate, and reengineer basic to complex electrical schematic and layout drawings and drawing packets of industrial control panels&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/electrical-designer\/\" name=\"Electrical Designer\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Responsibilities Create, duplicate, and reengineer basic to complex electrical schematic and layout drawings and drawing packets of industrial control panels&hellip;","address":", FL, USA","location":{"lat":"27.6648274","state":"FL","country":"United States","lng":"-81.5157535","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/electrical-designer\/","zoom":19,"extra_fields":{"post_excerpt":"Responsibilities Create, duplicate, and reengineer basic to complex electrical schematic and layout drawings and drawing packets of industrial control panels&hellip;","post_content":"<p>Responsibilities<\/p>\n<p>Create, duplicate, and reengineer basic to complex electrical schematic and layout drawings and <\/p>\n<p>drawing packets of industrial control panels and associated equipment for automation and drive <\/p>\n<p>systems. Design systems from performance related specifications and\/or concepts.<\/p>\n<p>Participate with other engineers in some, or all of the following project development phases:<\/p>\n<p>\u2022 Design, specify, and supervise fabrication and assembly of designed systems and <\/p>\n<p>subsystems.<\/p>\n<p>\u2022 Create project specifications for projects that summarize and detail customer <\/p>\n<p>requirements.<\/p>\n<p>\u2022 Interface with customers, project managers, systems engineers, fabrication technicians, <\/p>\n<p>and sales professionals for successful completion of the project.<\/p>\n<p>\u2022 Demonstrate a high level of professionalism, technical competence, and outstanding <\/p>\n<p>safety performance.<\/p>\n<p>Essential Functions<\/p>\n<p>\u2022 Create electrical assemblies, schematics, layouts, bills of materials (BOM\u2019s), conduit and <\/p>\n<p>cable schedules, and system documentation using AutoCAD Electrical. Create assembly <\/p>\n<p>and schematic drawings per company and customer specifications.<\/p>\n<p>\u2022 Use Autodesk Vault to maintain all engineering documents.<\/p>\n<p>\u2022 Provide recommendations for electrical specifications on components to be implemented <\/p>\n<p>in the assemblies.<\/p>\n<p>\u2022 Conduct design reviews with engineering team to obtain design improvements, quality <\/p>\n<p>improvements, cost savings, and\/or assembly improvements.<\/p>\n<p>\u2022 Examine existing, including possibly damaged, components and equipment for accuracy, <\/p>\n<p>improvement, reproduction and\/or replacement including but not limited to general <\/p>\n<p>precisions measurements, operation or function of item, and other design <\/p>\n<p>notes\/considerations.<\/p>\n<p>\u2022 Maintain working drawing sets with approved revisions and \u201cas-built\u201d changes.<\/p>\n<p>\u2022 Prepare purchase requisitions for project related materials.<\/p>\n<p>\u2022 Provide design support to production during the fabrication phase of parts and electrical <\/p>\n<p>systems.<\/p>\n<p>Strong preference will be shown to candidates having additional experience with any of the <\/p>\n<p>following:<\/p>\n<p>\u2022 AutoCAD Electrical and Autodesk Vault<\/p>\n<p>\u2022 NEC 2017 or UL Electrical Standards<\/p>\n<p>\u2022 PLC, VFD, or MCC system design and specification<\/p>\n<p>Educational Requirements<\/p>\n<p>\u2022 Associates Degree or higher in an appropriate field of study. <\/p>\n<p>--- OR ---<\/p>\n<p>\u2022 2+ years of equivalent experience working with industrial automation control system<\/p>\n<p>design<\/p>","post_title":"Electrical Designer","post_link":"https:\/\/turnerstaffing.com\/position\/electrical-designer\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"","%location_country%":"United States","%location_city%":"","%location_state_id%":"FL","%location_state_name%":"Florida","%location_city_state%":"United States","%education%":"","%department%":"","%description%":"<p>Responsibilities<\/p>\n<p>Create, duplicate, and reengineer basic to complex electrical schematic and layout drawings and <\/p>\n<p>drawing packets of industrial control panels and associated equipment for automation and drive <\/p>\n<p>systems. Design systems from performance related specifications and\/or concepts.<\/p>\n<p>Participate with other engineers in some, or all of the following project development phases:<\/p>\n<p>\u2022 Design, specify, and supervise fabrication and assembly of designed systems and <\/p>\n<p>subsystems.<\/p>\n<p>\u2022 Create project specifications for projects that summarize and detail customer <\/p>\n<p>requirements.<\/p>\n<p>\u2022 Interface with customers, project managers, systems engineers, fabrication technicians, <\/p>\n<p>and sales professionals for successful completion of the project.<\/p>\n<p>\u2022 Demonstrate a high level of professionalism, technical competence, and outstanding <\/p>\n<p>safety performance.<\/p>\n<p>Essential Functions<\/p>\n<p>\u2022 Create electrical assemblies, schematics, layouts, bills of materials (BOM\u2019s), conduit and <\/p>\n<p>cable schedules, and system documentation using AutoCAD Electrical. Create assembly <\/p>\n<p>and schematic drawings per company and customer specifications.<\/p>\n<p>\u2022 Use Autodesk Vault to maintain all engineering documents.<\/p>\n<p>\u2022 Provide recommendations for electrical specifications on components to be implemented <\/p>\n<p>in the assemblies.<\/p>\n<p>\u2022 Conduct design reviews with engineering team to obtain design improvements, quality <\/p>\n<p>improvements, cost savings, and\/or assembly improvements.<\/p>\n<p>\u2022 Examine existing, including possibly damaged, components and equipment for accuracy, <\/p>\n<p>improvement, reproduction and\/or replacement including but not limited to general <\/p>\n<p>precisions measurements, operation or function of item, and other design <\/p>\n<p>notes\/considerations.<\/p>\n<p>\u2022 Maintain working drawing sets with approved revisions and \u201cas-built\u201d changes.<\/p>\n<p>\u2022 Prepare purchase requisitions for project related materials.<\/p>\n<p>\u2022 Provide design support to production during the fabrication phase of parts and electrical <\/p>\n<p>systems.<\/p>\n<p>Strong preference will be shown to candidates having additional experience with any of the <\/p>\n<p>following:<\/p>\n<p>\u2022 AutoCAD Electrical and Autodesk Vault<\/p>\n<p>\u2022 NEC 2017 or UL Electrical Standards<\/p>\n<p>\u2022 PLC, VFD, or MCC system design and specification<\/p>\n<p>Educational Requirements<\/p>\n<p>\u2022 Associates Degree or higher in an appropriate field of study. <\/p>\n<p>--- OR ---<\/p>\n<p>\u2022 2+ years of equivalent experience working with industrial automation control system<\/p>\n<p>design<\/p>","%category%":"Design","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/957b2a26f773-electrical-designer","%breezy_id%":"957b2a26f773","%breezy_friendly_id%":"957b2a26f773-electrical-designer","%breezy_created_date%":"2026-01-22T21:07:47.312Z","%breezy_updated_date%":"2026-01-22T21:08:29.058Z","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"FL","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":", FL, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"27.6648274","%_wpgmp_metabox_longitude%":"-81.5157535","%rank_math_internal_links_processed%":"1"}},"id":3090,"infowindow_disable":false},{"source":"post","title":"Fuel\/Lube Technician &#8211; Mining","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Fuel\/Lube Technician &#8211; Mining\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Turner Mining Group &#8211; Heavy Equipment Fuel &amp; Lube Technician We are looking for a dynamic and talented professional to&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/fuel-lube-technician-mining\/\" name=\"Fuel\/Lube Technician &#8211; Mining\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Turner Mining Group &#8211; Heavy Equipment Fuel &amp; Lube Technician We are looking for a dynamic and talented professional to&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\/fuel-lube-technician-mining\/","zoom":19,"extra_fields":{"post_excerpt":"Turner Mining Group &#8211; Heavy Equipment Fuel &amp; Lube Technician We are looking for a dynamic and talented professional to&hellip;","post_content":"<p><strong><u>Turner Mining Group - Heavy Equipment Fuel &amp; Lube Technician<\/u><\/strong><\/p><p>We are looking for a dynamic and talented professional to fill a <strong>Fuel &amp; Lube Technician<\/strong> role at our fast-growing, forward thinking mining services company.<\/p>\n\n<p style=\"color:#000000\"><span style=\"color:#333333\"> <\/span><\/p>\n<p>This person will function as a <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> <span style=\"color:#333333\"><\/span><\/p>\n\n\n<p><strong>Essential Skills &amp; Knowledge<\/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 minor repairs on equipment using tools, machine tools and measuring instruments <\/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 Operate and test 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\"><span style=\"color:#333333\"> <\/span><\/p>\n<p><strong>Benefits<\/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\"> <\/span><\/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>\n<p><\/p>","post_title":"Fuel\/Lube Technician &#8211; Mining","post_link":"https:\/\/turnerstaffing.com\/position\/fuel-lube-technician-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%":"Maintenance","%description%":"<p><strong><u>Turner Mining Group - Heavy Equipment Fuel &amp; Lube Technician<\/u><\/strong><\/p><p>We are looking for a dynamic and talented professional to fill a <strong>Fuel &amp; Lube Technician<\/strong> role at our fast-growing, forward thinking mining services company.<\/p>\n\n<p style=\"color:#000000;\"><span style=\"color:#333333;\"> <\/span><\/p>\n<p>This person will function as a <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> <span style=\"color:#333333;\"><\/span><\/p>\n\n\n<p><strong>Essential Skills &amp; Knowledge<\/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 minor repairs on equipment using tools, machine tools and measuring instruments <\/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 Operate and test 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;\"><span style=\"color:#333333;\"> <\/span><\/p>\n<p><strong>Benefits<\/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;\"> <\/span><\/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>\n<p><\/p>","%category%":"Other","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/487a4c73e6ac-fuel-lube-technician-mining","%breezy_id%":"487a4c73e6ac","%breezy_friendly_id%":"487a4c73e6ac-fuel-lube-technician-mining","%breezy_created_date%":"2026-01-22T20:49:28.678Z","%breezy_updated_date%":"2026-01-22T20:49:49.076Z","%_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":3089,"infowindow_disable":false},{"source":"post","title":"Entry Level Miner","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Entry Level Miner\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Entry Level Miner &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; Reports to:&nbsp;Foreman \u2013 Turner Mining Group Job Description: The Entry Level Miner is a starting point&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/entry-level-miner-3\/\" name=\"Entry Level Miner\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Entry Level Miner &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; Reports to:&nbsp;Foreman \u2013 Turner Mining Group Job Description: The Entry Level Miner is a starting point&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\/entry-level-miner-3\/","zoom":19,"extra_fields":{"post_excerpt":"Entry Level Miner &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; Reports to:&nbsp;Foreman \u2013 Turner Mining Group Job Description: The Entry Level Miner is a starting point&hellip;","post_content":"<p><strong>Entry Level Miner<\/strong>    &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&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><strong>Reports to:&nbsp;<\/strong><strong>Foreman \u2013 Turner Mining Group<\/strong><\/p>\n<p><strong>Job Description:<\/strong><\/p>\n<p>The Entry Level Miner is a starting point for both operations and maintenance within Turner Mining Group. This position will develop into a Production Miner or Fuel \/ Lube Technician role. The successful candidate must live the Turner Values and be an outward example to others. This position must demonstrate a strong commitment to \u201cSafe Production\u201d through decision making, priorities, and client relations.<\/p>\n<p><strong>Objectives and Contributions:<\/strong><\/p>\n<p>The Entry Level Miner is focused on key aspects that drive communication and safe production while maintaining a high level of efficiency, and preventative maintenance awareness requirements. The Entry Level Miner demonstrates safety ownership at a personal level and holds other crew members to the same high standard.<\/p>\n<ul><li>Work with employees to ensure a high level of accuracy and engagement on hazard identification and control<\/li><li>Engage crews and leadership to define processes that motivate working towards common goals<\/li><li>Assist with MSHA regulatory task training and verify compliance to standards<\/li><li>Live the values as part of a visible daily decision-making process<\/li><li>Involvement in risk assessment processes at various levels of the organization<\/li><li>Holds themselves and others accountable for acting like an owner (taking care of equipment, not wasting resources, using time wisely, and being accountable for conditions and behaviors)<\/li><li>Maintains a high standard of housekeeping (machine and work areas)<\/li><\/ul>\n<p><u>Culture and Communication:<\/u><\/p>\n<ul><li>Can effectively communicate in English (multi-lingual preferred)<\/li><li>Work with crews to support proactive near miss reporting<\/li><li>Leads by example (walks the talk)<\/li><\/ul>\n<p><u>Systems:<\/u><\/p>\n<ul><li>Trains to Turner standards to perform quality pre-operation machine inspections (Based on mobile equipment physical demands analysis)<\/li><li>Trains to Turner standards to accurately document 5000-23 and training checklist requirements<\/li><li>Other regulatory &amp; internal \/ external forms as required<\/li><li>Maintains a valid and insurable driving license<\/li><\/ul>\n<p><u>Travel and New Site Development:<\/u><\/p>\n<p><u>Time and Interactions:<\/u><\/p>\n<ul><li>The Entry Level Miner must be flexible on shift schedules (days and nights) to assist with training and production needs<\/li><li>The Entry Level Miner will be self-starting, motivated, with a strong desire to be part of a team and to influence improvement. Communication is also critical to keep leadership and site-based personnel in the loop of successes, challenges, and any additional support that may be required<\/li><li>Excellent time management skills<\/li><\/ul>\n<p><u>Qualifications:<\/u><\/p>\n<ul><li>Willingness and ability to adhere to OSHA \/ MSHA regulatory requirements<\/li><li>Entry Level Miners will be subject to a probationary period of six months from the date of hire<\/li><li>0-1 years\u2019 experience in mining \/ heavy industry preferred<\/li><li>Ability to obtain a working knowledge of safety systems and processes<\/li><li>Appropriate attention to detail required<\/li><li>Strong communication skills<\/li><li>Strong morals and values<\/li><li>Exemplary attendance record<\/li><li>Exemplary safety and disciplinary record<\/li><li>Willingness to be flexible on daily job duty requirements<\/li><li>Maintains a positive outspoken learning attitude<\/li><\/ul>\n<ul><li>The Entry Level Miner will become competent and highly proficient on each piece of the following equipment through on-the-job training and skills qualification<ul><li><strong>Water truck<\/strong><\/li><li><strong>Haulage Truc<\/strong><strong>k<\/strong><\/li><li><strong>OR<\/strong><\/li><li><strong>Preventative Maintenance<\/strong><\/li><li><strong>Fuel \/ Lube Truck<\/strong><\/li><\/ul><\/li><\/ul>\n<p><u>Other Duties:<\/u><\/p>\n<ul><li>In addition to the job skills above, there may be requirements for manual tasks to be completed to meet other business needs. Operators in any job duty classification may be required to participate in these additional tasks.<\/li><\/ul>\n<p><u><strong>Benefits<\/strong><\/u><br>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. 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>\n<p><\/p>","post_title":"Entry Level Miner","post_link":"https:\/\/turnerstaffing.com\/position\/entry-level-miner-3\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Entry Level","%location_country%":"United States","%location_city%":"Ely","%location_state_id%":"NV","%location_state_name%":"Nevada","%location_city_state%":"Ely, NV","%education%":"Unspecified","%department%":"Operations","%description%":"<p><strong>Entry Level Miner<\/strong>    &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&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><strong>Reports to:&nbsp;<\/strong><strong>Foreman \u2013 Turner Mining Group<\/strong><\/p>\n<p><strong>Job Description:<\/strong><\/p>\n<p>The Entry Level Miner is a starting point for both operations and maintenance within Turner Mining Group. This position will develop into a Production Miner or Fuel \/ Lube Technician role. The successful candidate must live the Turner Values and be an outward example to others. This position must demonstrate a strong commitment to \u201cSafe Production\u201d through decision making, priorities, and client relations.<\/p>\n<p><strong>Objectives and Contributions:<\/strong><\/p>\n<p>The Entry Level Miner is focused on key aspects that drive communication and safe production while maintaining a high level of efficiency, and preventative maintenance awareness requirements. The Entry Level Miner demonstrates safety ownership at a personal level and holds other crew members to the same high standard.<\/p>\n<ul><li>Work with employees to ensure a high level of accuracy and engagement on hazard identification and control<\/li><li>Engage crews and leadership to define processes that motivate working towards common goals<\/li><li>Assist with MSHA regulatory task training and verify compliance to standards<\/li><li>Live the values as part of a visible daily decision-making process<\/li><li>Involvement in risk assessment processes at various levels of the organization<\/li><li>Holds themselves and others accountable for acting like an owner (taking care of equipment, not wasting resources, using time wisely, and being accountable for conditions and behaviors)<\/li><li>Maintains a high standard of housekeeping (machine and work areas)<\/li><\/ul>\n<p><u>Culture and Communication:<\/u><\/p>\n<ul><li>Can effectively communicate in English (multi-lingual preferred)<\/li><li>Work with crews to support proactive near miss reporting<\/li><li>Leads by example (walks the talk)<\/li><\/ul>\n<p><u>Systems:<\/u><\/p>\n<ul><li>Trains to Turner standards to perform quality pre-operation machine inspections (Based on mobile equipment physical demands analysis)<\/li><li>Trains to Turner standards to accurately document 5000-23 and training checklist requirements<\/li><li>Other regulatory &amp; internal \/ external forms as required<\/li><li>Maintains a valid and insurable driving license<\/li><\/ul>\n<p><u>Travel and New Site Development:<\/u><\/p>\n<p><u>Time and Interactions:<\/u><\/p>\n<ul><li>The Entry Level Miner must be flexible on shift schedules (days and nights) to assist with training and production needs<\/li><li>The Entry Level Miner will be self-starting, motivated, with a strong desire to be part of a team and to influence improvement. Communication is also critical to keep leadership and site-based personnel in the loop of successes, challenges, and any additional support that may be required<\/li><li>Excellent time management skills<\/li><\/ul>\n<p><u>Qualifications:<\/u><\/p>\n<ul><li>Willingness and ability to adhere to OSHA \/ MSHA regulatory requirements<\/li><li>Entry Level Miners will be subject to a probationary period of six months from the date of hire<\/li><li>0-1 years\u2019 experience in mining \/ heavy industry preferred<\/li><li>Ability to obtain a working knowledge of safety systems and processes<\/li><li>Appropriate attention to detail required<\/li><li>Strong communication skills<\/li><li>Strong morals and values<\/li><li>Exemplary attendance record<\/li><li>Exemplary safety and disciplinary record<\/li><li>Willingness to be flexible on daily job duty requirements<\/li><li>Maintains a positive outspoken learning attitude<\/li><\/ul>\n<ul><li>The Entry Level Miner will become competent and highly proficient on each piece of the following equipment through on-the-job training and skills qualification<ul><li><strong>Water truck<\/strong><\/li><li><strong>Haulage Truc<\/strong><strong>k<\/strong><\/li><li><strong>OR<\/strong><\/li><li><strong>Preventative Maintenance<\/strong><\/li><li><strong>Fuel \/ Lube Truck<\/strong><\/li><\/ul><\/li><\/ul>\n<p><u>Other Duties:<\/u><\/p>\n<ul><li>In addition to the job skills above, there may be requirements for manual tasks to be completed to meet other business needs. Operators in any job duty classification may be required to participate in these additional tasks.<\/li><\/ul>\n<p><u><strong>Benefits<\/strong><\/u><br>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. 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>\n<p><\/p>","%category%":"Operations","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/f7ae9abafc55-entry-level-miner","%breezy_id%":"f7ae9abafc55","%breezy_friendly_id%":"f7ae9abafc55-entry-level-miner","%breezy_created_date%":"2026-01-22T15:42:08.593Z","%breezy_updated_date%":"2026-01-22T15:42:36.565Z","%_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":3075,"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    Production Miner &#8211; Haul&nbsp;Truck &#8211; Mining&nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp;&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":"Production Miner &#8211; Haul&nbsp;Truck &#8211; Mining&nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp;&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\/haul-truck-driver-mining\/","zoom":19,"extra_fields":{"post_excerpt":"Production Miner &#8211; Haul&nbsp;Truck &#8211; Mining&nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp;&hellip;","post_content":"<p><strong>Production Miner - Haul&nbsp;Truck - Mining<\/strong>&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><strong>Reports to:&nbsp;<\/strong><strong>Foreman \u2013 Turner Mining Group<\/strong><\/p>\n<p><strong>Job Description:<\/strong><\/p>\n<p>The Production Miner is a developing mining operator position within Turner Mining Group. The successful candidate must live the Turner Values and be an outward example to others. This position must demonstrate a strong commitment to \u201cSafe Production\u201d through decision making, priorities, and client relations.<\/p>\n<p><strong>Objectives and Contributions:<\/strong><\/p>\n<p>The Production Miner is focused on key aspects that drive communication and safe production while maintaining a high level of efficiency, and preventative maintenance awareness requirements. The Production Miner demonstrates safety ownership at a personal level and holds other crew members to the same high standard.&nbsp; The Production Miner will train and develop into the Equipment Operator job scope while the Equipment operator is filling in for the Senior job duties.<\/p>\n<ul><li>Work with employees to ensure a high level of accuracy and engagement on hazard identification and control<\/li><li>Engage crews and leadership to define processes that motivate working towards common goals<\/li><li>Assist with MSHA regulatory task training and verify compliance to standards<\/li><li>Live the values as part of a visible daily decision-making process<\/li><li>Assist with training proficiency audits<\/li><li>Involvement in risk assessment processes at various levels of the organization<\/li><li>Holds themselves and others accountable for acting like an owner (taking care of equipment, not wasting resources, using time wisely, and being accountable for conditions and behaviors)<\/li><li>Maintains a high standard of housekeeping (machine and work areas)<\/li><\/ul>\n<p><u>Culture and Communication:<\/u><\/p>\n<ul><li>Can effectively communicate in English (multi-lingual preferred)<\/li><li>Participate in site and project leaders to identify areas of improvement<\/li><li>Work with crews to support proactive near miss reporting<\/li><li>Leads by example (walks the talk)<\/li><\/ul>\n<p><u>Systems:<\/u><\/p>\n<ul><li>Ability to perform quality pre-operation machine inspections (Based on mobile equipment physical demands analysis)<\/li><li>Accurately documents 5000-23 and training checklist requirements<\/li><li>Other regulatory &amp; internal \/ external forms as required<\/li><li>Maintains a valid and insurable driving license<\/li><\/ul>\n<p><u>Travel and New Site Development:<\/u><\/p>\n<p><u>Time and Interactions:<\/u><\/p>\n<ul><li>The Production Miner must be flexible on shift schedules (days and nights) to assist with training and production needs<\/li><li>The Production Miner will be self-starting, motivated, with a strong desire to be part of a team and to influence improvement. Communication is also critical to keep leadership and site-based personnel in the loop of successes, challenges, and any additional support that may be required<\/li><li>Excellent time management skills<\/li><\/ul>\n<p><u>Qualifications:<\/u><\/p>\n<ul><li>Willingness and ability to adhere to OSHA \/ MSHA regulatory requirements<\/li><li>Production Miner will be subject to a probationary period of six months from the date of hire<\/li><li>0-2 years\u2019 experience in mining \/ heavy industry preferred<\/li><li>Working knowledge of safety systems and processes<\/li><li>Appropriate attention to detail required<\/li><li>Strong communication skills<\/li><li>Strong morals and values<\/li><li>Exemplary attendance record<\/li><li>Exemplary safety and disciplinary record<\/li><li>Willingness to be flexible on daily job duty requirements<\/li><li>Maintains a positive outspoken learning attitude<\/li><li>The Production Miner will be competent and highly proficient on each piece of the following equipment:<ul><li><strong>Water truck,<\/strong><\/li><li><strong>Haulage Truck<\/strong><\/li><\/ul><\/li><\/ul>\n<p><strong><u>Other Duties:<\/u><br><\/strong><\/p>\n<ul><li>In addition to the job skills above, there may be requirements for manual tasks to be completed to meet other business needs. Operators in any job duty classification may be required to participate in these additional tasks.<\/li><\/ul>","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%":"Associate","%location_country%":"United States","%location_city%":"Ely","%location_state_id%":"NV","%location_state_name%":"Nevada","%location_city_state%":"Ely, NV","%education%":"Unspecified","%department%":"","%description%":"<p><strong>Production Miner - Haul&nbsp;Truck - Mining<\/strong>&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><strong>Reports to:&nbsp;<\/strong><strong>Foreman \u2013 Turner Mining Group<\/strong><\/p>\n<p><strong>Job Description:<\/strong><\/p>\n<p>The Production Miner is a developing mining operator position within Turner Mining Group. The successful candidate must live the Turner Values and be an outward example to others. This position must demonstrate a strong commitment to \u201cSafe Production\u201d through decision making, priorities, and client relations.<\/p>\n<p><strong>Objectives and Contributions:<\/strong><\/p>\n<p>The Production Miner is focused on key aspects that drive communication and safe production while maintaining a high level of efficiency, and preventative maintenance awareness requirements. The Production Miner demonstrates safety ownership at a personal level and holds other crew members to the same high standard.&nbsp; The Production Miner will train and develop into the Equipment Operator job scope while the Equipment operator is filling in for the Senior job duties.<\/p>\n<ul><li>Work with employees to ensure a high level of accuracy and engagement on hazard identification and control<\/li><li>Engage crews and leadership to define processes that motivate working towards common goals<\/li><li>Assist with MSHA regulatory task training and verify compliance to standards<\/li><li>Live the values as part of a visible daily decision-making process<\/li><li>Assist with training proficiency audits<\/li><li>Involvement in risk assessment processes at various levels of the organization<\/li><li>Holds themselves and others accountable for acting like an owner (taking care of equipment, not wasting resources, using time wisely, and being accountable for conditions and behaviors)<\/li><li>Maintains a high standard of housekeeping (machine and work areas)<\/li><\/ul>\n<p><u>Culture and Communication:<\/u><\/p>\n<ul><li>Can effectively communicate in English (multi-lingual preferred)<\/li><li>Participate in site and project leaders to identify areas of improvement<\/li><li>Work with crews to support proactive near miss reporting<\/li><li>Leads by example (walks the talk)<\/li><\/ul>\n<p><u>Systems:<\/u><\/p>\n<ul><li>Ability to perform quality pre-operation machine inspections (Based on mobile equipment physical demands analysis)<\/li><li>Accurately documents 5000-23 and training checklist requirements<\/li><li>Other regulatory &amp; internal \/ external forms as required<\/li><li>Maintains a valid and insurable driving license<\/li><\/ul>\n<p><u>Travel and New Site Development:<\/u><\/p>\n<p><u>Time and Interactions:<\/u><\/p>\n<ul><li>The Production Miner must be flexible on shift schedules (days and nights) to assist with training and production needs<\/li><li>The Production Miner will be self-starting, motivated, with a strong desire to be part of a team and to influence improvement. Communication is also critical to keep leadership and site-based personnel in the loop of successes, challenges, and any additional support that may be required<\/li><li>Excellent time management skills<\/li><\/ul>\n<p><u>Qualifications:<\/u><\/p>\n<ul><li>Willingness and ability to adhere to OSHA \/ MSHA regulatory requirements<\/li><li>Production Miner will be subject to a probationary period of six months from the date of hire<\/li><li>0-2 years\u2019 experience in mining \/ heavy industry preferred<\/li><li>Working knowledge of safety systems and processes<\/li><li>Appropriate attention to detail required<\/li><li>Strong communication skills<\/li><li>Strong morals and values<\/li><li>Exemplary attendance record<\/li><li>Exemplary safety and disciplinary record<\/li><li>Willingness to be flexible on daily job duty requirements<\/li><li>Maintains a positive outspoken learning attitude<\/li><li>The Production Miner will be competent and highly proficient on each piece of the following equipment:<ul><li><strong>Water truck,<\/strong><\/li><li><strong>Haulage Truck<\/strong><\/li><\/ul><\/li><\/ul>\n<p><strong><u>Other Duties:<\/u><br><\/strong><\/p>\n<ul><li>In addition to the job skills above, there may be requirements for manual tasks to be completed to meet other business needs. Operators in any job duty classification may be required to participate in these additional tasks.<\/li><\/ul>","%category%":"Operations","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/9d50fa0805aa-haul-truck-driver-mining","%breezy_id%":"9d50fa0805aa","%breezy_friendly_id%":"9d50fa0805aa-haul-truck-driver-mining","%breezy_created_date%":"2026-01-22T15:48:54.762Z","%breezy_updated_date%":"2026-01-22T15:49:24.026Z","%_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":3076,"infowindow_disable":false},{"source":"post","title":"AP Clerk","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    AP Clerk\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Turner Staffing Group is seeking an experienced&nbsp;Accounts Payable (AP) Clerk&nbsp;to support a client project in the&nbsp;Elko, Nevada&nbsp;area. This is a&nbsp;short-term&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/ap-clerk\/\" name=\"AP Clerk\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Turner Staffing Group is seeking an experienced&nbsp;Accounts Payable (AP) Clerk&nbsp;to support a client project in the&nbsp;Elko, Nevada&nbsp;area. This is a&nbsp;short-term&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\/ap-clerk\/","zoom":19,"extra_fields":{"post_excerpt":"Turner Staffing Group is seeking an experienced&nbsp;Accounts Payable (AP) Clerk&nbsp;to support a client project in the&nbsp;Elko, Nevada&nbsp;area. This is a&nbsp;short-term&hellip;","post_content":"<p>Turner Staffing Group is seeking an experienced&nbsp;<strong>Accounts Payable (AP) Clerk<\/strong>&nbsp;to support a client project in the&nbsp;<strong>Elko, Nevada<\/strong>&nbsp;area. This is a&nbsp;<strong>short-term (2-3 months), onsite assignment<\/strong>&nbsp;supporting finance and accounting operations in a fast-paced, project-driven environment.<\/p>\n<p>The ideal candidate brings strong attention to detail, experience processing high-volume invoices, and the ability to collaborate closely with project and operations teams.<\/p>\n<p><strong><strong>Position Overview<\/strong><\/strong><\/p>\n<p>The Accounts Payable Clerk is responsible for accurately and timely processing vendor invoices, expense reports, and related financial transactions. This role plays a critical part in maintaining compliance with company policies, supporting project cost tracking, and ensuring positive vendor relationships.<\/p>\n<p><strong><strong>Key Responsibilities<\/strong><\/strong><\/p>\n<ul><li>Process, verify, and reconcile vendor invoices and expense reports accurately and on time<\/li><li>Handle invoice processing specific to&nbsp;<strong>mining and project-based operations<\/strong><\/li><li>Ensure compliance with internal accounting policies and procedures<\/li><li>Communicate with vendors to resolve invoice discrepancies promptly and professionally<\/li><li>Build and maintain positive relationships with key suppliers<\/li><li>Code and categorize expenses accurately to support tracking and reporting<\/li><li>Collaborate with project managers to understand project-specific financial activity<\/li><li>Support budget tracking and basic financial analysis as needed<\/li><li>Utilize&nbsp;<strong>SAP, MS Excel, and AP systems<\/strong>&nbsp;to support efficient financial workflows<\/li><li>Contribute to the continuous improvement of financial processes and systems<\/li><\/ul>\n<p><strong><strong>Essential Skills &amp; Qualifications<\/strong><\/strong><\/p>\n<ul><li>Proven experience in&nbsp;<strong>accounts payable or a related accounting role<\/strong><\/li><li>Proficiency with&nbsp;<strong>SAP<\/strong>,&nbsp;<strong>Microsoft Excel<\/strong>, and AP software<\/li><li>Exceptional attention to detail and data accuracy<\/li><li>Strong communication and interpersonal skills<\/li><li>Ability to work independently while collaborating effectively with a team<\/li><li>Understanding of&nbsp;<strong>project-based accounting<\/strong>&nbsp;principles strongly preferred<\/li><li>Strong organizational skills with a proactive, problem-solving mindset<\/li><li>Ability to work closely with project managers and business stakeholders<\/li><li>Local candidates only<\/li><li>Must be authorized to work in the US without work visa sponsorship<\/li><\/ul>\n<p><strong><strong>Education<\/strong><\/strong><\/p>\n<ul><li>Bachelor\u2019s degree in&nbsp;<strong>Accounting, Finance, or a related field<\/strong>&nbsp;preferred<\/li><\/ul>\n<p><strong><strong>What\u2019s Offered<\/strong><\/strong><\/p>\n<ul><li>Competitive compensation for a short-term assignment<\/li><li>Exposure to project-based accounting in a dynamic operational environment<\/li><li>Professional, collaborative workplace culture<\/li><li>Benefits include:<p><\/p><ul><li>Medical, Dental, Vision, Life Insurance<\/li><li>401(k) with company match<\/li><li>Paid time off<\/li><\/ul><\/li><\/ul>\n<p><strong><strong>Equal Opportunity Statement<\/strong><\/strong><\/p>\n<p>Turner Staffing Group and its client are committed to fostering an inclusive workplace. We are proud to be an&nbsp;<strong>equal opportunity and affirmative action employer<\/strong>, encouraging applications from all qualified individuals.<\/p>\n<p><strong><strong>Apply Today<\/strong><\/strong><\/p>\n<p>If you are a detail-oriented AP professional available for a short-term onsite assignment in Elko, NV, we encourage you to apply.<\/p>","post_title":"AP Clerk","post_link":"https:\/\/turnerstaffing.com\/position\/ap-clerk\/","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 seeking an experienced&nbsp;<strong>Accounts Payable (AP) Clerk<\/strong>&nbsp;to support a client project in the&nbsp;<strong>Elko, Nevada<\/strong>&nbsp;area. This is a&nbsp;<strong>short-term (2-3 months), onsite assignment<\/strong>&nbsp;supporting finance and accounting operations in a fast-paced, project-driven environment.<\/p>\n<p>The ideal candidate brings strong attention to detail, experience processing high-volume invoices, and the ability to collaborate closely with project and operations teams.<\/p>\n<p><strong><strong>Position Overview<\/strong><\/strong><\/p>\n<p>The Accounts Payable Clerk is responsible for accurately and timely processing vendor invoices, expense reports, and related financial transactions. This role plays a critical part in maintaining compliance with company policies, supporting project cost tracking, and ensuring positive vendor relationships.<\/p>\n<p><strong><strong>Key Responsibilities<\/strong><\/strong><\/p>\n<ul><li>Process, verify, and reconcile vendor invoices and expense reports accurately and on time<\/li><li>Handle invoice processing specific to&nbsp;<strong>mining and project-based operations<\/strong><\/li><li>Ensure compliance with internal accounting policies and procedures<\/li><li>Communicate with vendors to resolve invoice discrepancies promptly and professionally<\/li><li>Build and maintain positive relationships with key suppliers<\/li><li>Code and categorize expenses accurately to support tracking and reporting<\/li><li>Collaborate with project managers to understand project-specific financial activity<\/li><li>Support budget tracking and basic financial analysis as needed<\/li><li>Utilize&nbsp;<strong>SAP, MS Excel, and AP systems<\/strong>&nbsp;to support efficient financial workflows<\/li><li>Contribute to the continuous improvement of financial processes and systems<\/li><\/ul>\n<p><strong><strong>Essential Skills &amp; Qualifications<\/strong><\/strong><\/p>\n<ul><li>Proven experience in&nbsp;<strong>accounts payable or a related accounting role<\/strong><\/li><li>Proficiency with&nbsp;<strong>SAP<\/strong>,&nbsp;<strong>Microsoft Excel<\/strong>, and AP software<\/li><li>Exceptional attention to detail and data accuracy<\/li><li>Strong communication and interpersonal skills<\/li><li>Ability to work independently while collaborating effectively with a team<\/li><li>Understanding of&nbsp;<strong>project-based accounting<\/strong>&nbsp;principles strongly preferred<\/li><li>Strong organizational skills with a proactive, problem-solving mindset<\/li><li>Ability to work closely with project managers and business stakeholders<\/li><li>Local candidates only<\/li><li>Must be authorized to work in the US without work visa sponsorship<\/li><\/ul>\n<p><strong><strong>Education<\/strong><\/strong><\/p>\n<ul><li>Bachelor\u2019s degree in&nbsp;<strong>Accounting, Finance, or a related field<\/strong>&nbsp;preferred<\/li><\/ul>\n<p><strong><strong>What\u2019s Offered<\/strong><\/strong><\/p>\n<ul><li>Competitive compensation for a short-term assignment<\/li><li>Exposure to project-based accounting in a dynamic operational environment<\/li><li>Professional, collaborative workplace culture<\/li><li>Benefits include:<p><\/p><ul><li>Medical, Dental, Vision, Life Insurance<\/li><li>401(k) with company match<\/li><li>Paid time off<\/li><\/ul><\/li><\/ul>\n<p><strong><strong>Equal Opportunity Statement<\/strong><\/strong><\/p>\n<p>Turner Staffing Group and its client are committed to fostering an inclusive workplace. We are proud to be an&nbsp;<strong>equal opportunity and affirmative action employer<\/strong>, encouraging applications from all qualified individuals.<\/p>\n<p><strong><strong>Apply Today<\/strong><\/strong><\/p>\n<p>If you are a detail-oriented AP professional available for a short-term onsite assignment in Elko, NV, we encourage you to apply.<\/p>","%category%":"","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/32ad501123a7-ap-clerk","%breezy_id%":"32ad501123a7","%breezy_friendly_id%":"32ad501123a7-ap-clerk","%breezy_created_date%":"2026-01-22T17:23:24.162Z","%breezy_updated_date%":"2026-01-22T17:23:54.810Z","%_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":3077,"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 Job Description 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\/heavy-equipment-mechanic\/\" name=\"Heavy Equipment Mechanic\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Heavy Equipment Mechanic Job Description Do you love mining? Do you think differently? Are you ready to define the future&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\/heavy-equipment-mechanic\/","zoom":19,"extra_fields":{"post_excerpt":"Heavy Equipment Mechanic Job Description Do you love mining? Do you think differently? Are you ready to define the future&hellip;","post_content":"<p style=\"color:#000000\"><strong><u>Heavy Equipment Mechanic 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 Heavy Equipment Mechanic role at our fast-growing, forward thinking mining services company.<\/p>\n<p style=\"color:#000000\"><span style=\"color:#333333\">Turner Mining 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<\/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 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 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 Mechanic","post_link":"https:\/\/turnerstaffing.com\/position\/heavy-equipment-mechanic\/","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><u>Heavy Equipment Mechanic 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 Heavy Equipment Mechanic role at our fast-growing, forward thinking mining services company.<\/p>\n<p style=\"color:#000000;\"><span style=\"color:#333333;\">Turner Mining 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<\/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 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 & 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 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\/c2214ec217cd-heavy-equipment-mechanic","%breezy_id%":"c2214ec217cd","%breezy_friendly_id%":"c2214ec217cd-heavy-equipment-mechanic","%breezy_created_date%":"2021-11-29T20:47:10.000Z","%breezy_updated_date%":"2026-01-27T02:07:52.454Z","%_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":3074,"infowindow_disable":false},{"source":"post","title":"Project Accountant","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Project Accountant\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Project Accountant Reports to Project Manager\/Mine Manager Reporting to the Project Manager and working in close coordination with the Corporate&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/project-accountant\/\" name=\"Project Accountant\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Project Accountant Reports to Project Manager\/Mine Manager Reporting to the Project Manager and working in close coordination with the Corporate&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\/project-accountant\/","zoom":19,"extra_fields":{"post_excerpt":"Project Accountant Reports to Project Manager\/Mine Manager Reporting to the Project Manager and working in close coordination with the Corporate&hellip;","post_content":"<p>Project Accountant<\/p>\n<p>Reports to Project Manager\/Mine Manager<\/p>\n<p>Reporting to the Project Manager and working in close coordination with the Corporate Accounting team, the Project Accountant is responsible for all onsite accounting and financial reporting activities. This position ensures accurate cost tracking, contract compliance, and timely customer billing while supporting site leadership in understanding and managing project financial performance.<\/p>\n<p>The Project Accountant acts as the financial steward for the project, maintaining accuracy and transparency in all project-related transactions. The role requires strong analytical skills, attention to detail, and the ability to communicate effectively between field operations and the corporate accounting department.<\/p>\n<p>Position Responsibilities:<\/p>\n<p>Financial Management &amp; Reporting<\/p>\n<p>\u2022 Maintain accurate and up-to-date financial records for the project, including budgets, forecasts, and cost tracking.<\/p>\n<p>\u2022 Prepare and review detailed project cost reports comparing actual expenditures against budgets and forecasts.<\/p>\n<p>\u2022 Identify and communicate cost variances, trends, and potential overruns to project and corporate leadership.<\/p>\n<p>\u2022 Monitor project expenditures, accruals, and commitments to ensure data integrity.<\/p>\n<p>\u2022 Assist the Project Manager in preparing monthly project financial reviews and performance summaries.<\/p>\n<p>\u2022 Support management in evaluating project profitability and financial KPIs.<\/p>\n<p>\u2022 Ensure that all transactions and documentation align with company accounting policies and internal controls.<\/p>\n<p>\u2022 Prepare monthly, quarterly, and year-end reports as required by the corporate accounting schedule.<\/p>\n<p>Customer Billing &amp; Contract Compliance<\/p>\n<p>\u2022 Review mining services contract to identify and interpret key financial terms, including payment schedules, billing structure, retainage, and escalation clauses.<\/p>\n<p>\u2022 Compile field work order (FWO) data, quantities, and supporting documentation for client billing.<\/p>\n<p>\u2022 Prepare accurate and timely customer invoices in compliance with contractual terms and Turner\u2019s accounting standards.<\/p>\n<p>\u2022 Coordinate invoice submittal, client review, and payment tracking in partnership with the Project Manager.<\/p>\n<p>\u2022 Monitor accounts receivable status, follow up on outstanding invoices, and assist with collections as needed.<\/p>\n<p>\u2022 Support the Project Manager in preparing and submitting change orders, supporting cost documentation, and correspondence related to financial adjustments.<\/p>\n<p>Project Support &amp; Coordination<\/p>\n<p>\u2022 Work directly with site leadership to help interpret and control project financial results.<\/p>\n<p>\u2022 Provide guidance to foremen and superintendents regarding cost coding, purchase requisitions, and expense documentation.<\/p>\n<p>\u2022 Review and verify field data entries including timecards, equipment hours, and material quantities for accuracy and completeness.<\/p>\n<p>\u2022 Manage project-level administrative items such as insurance certifications, business licenses, and vendor documentation.<\/p>\n<p>\u2022 Support the Project Manager and Corporate Accounting team during audits, financial reviews, and internal reporting cycles.<\/p>\n<p>\u2022 Assist with onboarding and setup for new vendors, subcontractors, and suppliers in compliance with company policy.<\/p>\n<p>Systems &amp; Process Management<\/p>\n<p>\u2022 Enter, reconcile, and analyze project data using company accounting systems (Sage Intacct or equivalent ERP).<\/p>\n<p>\u2022 Maintain cost code integrity and consistency across project reporting systems (HeavyJob, Intacct, and Excel trackers).<\/p>\n<p>\u2022 Ensure all purchase orders, invoices, and receipts are properly coded and approved.<\/p>\n<p>\u2022 Support month-end close and reconciliation processes in coordination with Corporate Accounting.<\/p>\n<p>\u2022 Recommend and implement improvements to project financial management processes and reporting tools.<\/p>\n<p>The Ideal Candidate<\/p>\n<p>Knowledge<\/p>\n<p>\u2022 Bachelor\u2019s degree in accounting, finance, or related field.<\/p>\n<p>\u2022 3\u20135 years of experience in project or management accounting, preferably in mining, heavy civil, or industrial construction.<\/p>\n<p>\u2022 Strong understanding of project-based accounting and cost control principles.<\/p>\n<p>\u2022 Working knowledge of contracts, pay applications, and change order processes.<\/p>\n<p>\u2022 Proficiency in ERP systems (Sage Intacct preferred) and advanced Excel capabilities.<\/p>\n<p>\u2022 Familiarity with project management systems such as HCSS HeavyJob, Procore, or similar tools.<\/p>\n<p>\u2022 Understanding of GAAP and internal control procedures.<\/p>\n<p>Key Competencies \/ Skills<\/p>\n<p>\u2022 Analytical, detail-oriented, and able to interpret complex financial data.<\/p>\n<p>\u2022 Strong communicator who can translate financial results into actionable information for field leaders.<\/p>\n<p>\u2022 Proactive and organized, able to manage multiple priorities and meet tight deadlines.<\/p>\n<p>\u2022 Demonstrates initiative, accountability, and professionalism in all interactions.<\/p>\n<p>\u2022 Capable of working independently while collaborating effectively with site and corporate teams.<\/p>\n<p>\u2022 High degree of integrity and commitment to maintaining confidentiality and accuracy.<\/p>\n<p>\u2022 Committed to Turner\u2019s values and to supporting the success of project leadership and corporate goals.<\/p>","post_title":"Project Accountant","post_link":"https:\/\/turnerstaffing.com\/position\/project-accountant\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Mid Level","%location_country%":"United States","%location_city%":"Ely","%location_state_id%":"NV","%location_state_name%":"Nevada","%location_city_state%":"Ely, NV","%education%":"Bachelor's Degree","%department%":"","%description%":"<p>Project Accountant<\/p>\n<p>Reports to Project Manager\/Mine Manager<\/p>\n<p>Reporting to the Project Manager and working in close coordination with the Corporate Accounting team, the Project Accountant is responsible for all onsite accounting and financial reporting activities. This position ensures accurate cost tracking, contract compliance, and timely customer billing while supporting site leadership in understanding and managing project financial performance.<\/p>\n<p>The Project Accountant acts as the financial steward for the project, maintaining accuracy and transparency in all project-related transactions. The role requires strong analytical skills, attention to detail, and the ability to communicate effectively between field operations and the corporate accounting department.<\/p>\n<p>Position Responsibilities:<\/p>\n<p>Financial Management &amp; Reporting<\/p>\n<p>\u2022 Maintain accurate and up-to-date financial records for the project, including budgets, forecasts, and cost tracking.<\/p>\n<p>\u2022 Prepare and review detailed project cost reports comparing actual expenditures against budgets and forecasts.<\/p>\n<p>\u2022 Identify and communicate cost variances, trends, and potential overruns to project and corporate leadership.<\/p>\n<p>\u2022 Monitor project expenditures, accruals, and commitments to ensure data integrity.<\/p>\n<p>\u2022 Assist the Project Manager in preparing monthly project financial reviews and performance summaries.<\/p>\n<p>\u2022 Support management in evaluating project profitability and financial KPIs.<\/p>\n<p>\u2022 Ensure that all transactions and documentation align with company accounting policies and internal controls.<\/p>\n<p>\u2022 Prepare monthly, quarterly, and year-end reports as required by the corporate accounting schedule.<\/p>\n<p>Customer Billing &amp; Contract Compliance<\/p>\n<p>\u2022 Review mining services contract to identify and interpret key financial terms, including payment schedules, billing structure, retainage, and escalation clauses.<\/p>\n<p>\u2022 Compile field work order (FWO) data, quantities, and supporting documentation for client billing.<\/p>\n<p>\u2022 Prepare accurate and timely customer invoices in compliance with contractual terms and Turner\u2019s accounting standards.<\/p>\n<p>\u2022 Coordinate invoice submittal, client review, and payment tracking in partnership with the Project Manager.<\/p>\n<p>\u2022 Monitor accounts receivable status, follow up on outstanding invoices, and assist with collections as needed.<\/p>\n<p>\u2022 Support the Project Manager in preparing and submitting change orders, supporting cost documentation, and correspondence related to financial adjustments.<\/p>\n<p>Project Support &amp; Coordination<\/p>\n<p>\u2022 Work directly with site leadership to help interpret and control project financial results.<\/p>\n<p>\u2022 Provide guidance to foremen and superintendents regarding cost coding, purchase requisitions, and expense documentation.<\/p>\n<p>\u2022 Review and verify field data entries including timecards, equipment hours, and material quantities for accuracy and completeness.<\/p>\n<p>\u2022 Manage project-level administrative items such as insurance certifications, business licenses, and vendor documentation.<\/p>\n<p>\u2022 Support the Project Manager and Corporate Accounting team during audits, financial reviews, and internal reporting cycles.<\/p>\n<p>\u2022 Assist with onboarding and setup for new vendors, subcontractors, and suppliers in compliance with company policy.<\/p>\n<p>Systems &amp; Process Management<\/p>\n<p>\u2022 Enter, reconcile, and analyze project data using company accounting systems (Sage Intacct or equivalent ERP).<\/p>\n<p>\u2022 Maintain cost code integrity and consistency across project reporting systems (HeavyJob, Intacct, and Excel trackers).<\/p>\n<p>\u2022 Ensure all purchase orders, invoices, and receipts are properly coded and approved.<\/p>\n<p>\u2022 Support month-end close and reconciliation processes in coordination with Corporate Accounting.<\/p>\n<p>\u2022 Recommend and implement improvements to project financial management processes and reporting tools.<\/p>\n<p>The Ideal Candidate<\/p>\n<p>Knowledge<\/p>\n<p>\u2022 Bachelor\u2019s degree in accounting, finance, or related field.<\/p>\n<p>\u2022 3\u20135 years of experience in project or management accounting, preferably in mining, heavy civil, or industrial construction.<\/p>\n<p>\u2022 Strong understanding of project-based accounting and cost control principles.<\/p>\n<p>\u2022 Working knowledge of contracts, pay applications, and change order processes.<\/p>\n<p>\u2022 Proficiency in ERP systems (Sage Intacct preferred) and advanced Excel capabilities.<\/p>\n<p>\u2022 Familiarity with project management systems such as HCSS HeavyJob, Procore, or similar tools.<\/p>\n<p>\u2022 Understanding of GAAP and internal control procedures.<\/p>\n<p>Key Competencies \/ Skills<\/p>\n<p>\u2022 Analytical, detail-oriented, and able to interpret complex financial data.<\/p>\n<p>\u2022 Strong communicator who can translate financial results into actionable information for field leaders.<\/p>\n<p>\u2022 Proactive and organized, able to manage multiple priorities and meet tight deadlines.<\/p>\n<p>\u2022 Demonstrates initiative, accountability, and professionalism in all interactions.<\/p>\n<p>\u2022 Capable of working independently while collaborating effectively with site and corporate teams.<\/p>\n<p>\u2022 High degree of integrity and commitment to maintaining confidentiality and accuracy.<\/p>\n<p>\u2022 Committed to Turner\u2019s values and to supporting the success of project leadership and corporate goals.<\/p>","%category%":"Finance","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/c01ec92d4757-project-accountant","%breezy_id%":"c01ec92d4757","%breezy_friendly_id%":"c01ec92d4757-project-accountant","%breezy_created_date%":"2026-01-21T18:00:03.232Z","%breezy_updated_date%":"2026-01-28T15:01:31.956Z","%_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":3070,"infowindow_disable":false},{"source":"post","title":"Diesel Mechanic","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Diesel Mechanic\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Job Title: Diesel Mechanic Location: Marana, AZ Job Type: Full-Time Job Overview: Turner Staffing Group is partnered with a mining&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/diesel-mechanic\/\" name=\"Diesel Mechanic\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Job Title: Diesel Mechanic Location: Marana, AZ Job Type: Full-Time Job Overview: Turner Staffing Group is partnered with a mining&hellip;","address":"Marana, AZ, USA","location":{"lat":"32.436381","city":"Marana","state":"AZ","country":"United States","lng":"-111.2224422","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/diesel-mechanic\/","zoom":19,"extra_fields":{"post_excerpt":"Job Title: Diesel Mechanic Location: Marana, AZ Job Type: Full-Time Job Overview: Turner Staffing Group is partnered with a mining&hellip;","post_content":"<p><strong>Job Title:<\/strong> Diesel Mechanic<br>\n<strong>Location:<\/strong> Marana, AZ<br>\n<strong>Job Type:<\/strong> Full-Time<\/p>\n<p><strong>Job Overview:<\/strong><br>\nTurner Staffing Group is partnered with a mining company in Marana, Arizona that is seeking experienced <strong>Diesel Mechanics<\/strong> to join their maintenance team. This role is responsible for diagnosing, repairing, and maintaining heavy mobile equipment and support equipment to ensure safe and reliable mine operations.<\/p>\n<p><strong>Key Responsibilities:<\/strong><\/p>\n<ul>\n<li>\n<p>Perform preventive maintenance and repairs on heavy mining equipment, including haul trucks, loaders, dozers, excavators, and support equipment<\/p>\n<\/li>\n<li>\n<p>Diagnose mechanical, hydraulic, and electrical issues using appropriate diagnostic tools<\/p>\n<\/li>\n<li>\n<p>Troubleshoot and repair engines, transmissions, braking systems, and hydraulic systems<\/p>\n<\/li>\n<li>\n<p>Conduct inspections to identify wear, damage, or safety concerns<\/p>\n<\/li>\n<li>\n<p>Complete work orders and maintenance documentation accurately and timely<\/p>\n<\/li>\n<li>\n<p>Follow MSHA regulations and company safety procedures at all times<\/p>\n<\/li>\n<li>\n<p>Work closely with operations and maintenance teams to minimize equipment downtime<\/p>\n<\/li>\n<li>\n<p>Maintain a clean and organized work area<\/p>\n<\/li>\n<li>\n<p>Assist with component rebuilds and field repairs as needed<\/p>\n<\/li>\n<\/ul>\n<p><strong>Qualifications:<\/strong><\/p>\n<ul>\n<li>\n<p>High school diploma or GED required; technical or trade school preferred<\/p>\n<\/li>\n<li>\n<p>Minimum of 3\u20135 years of experience as a Diesel Mechanic, preferably in a mining or heavy equipment environment<\/p>\n<\/li>\n<li>\n<p>Strong knowledge of diesel engines, hydraulics, and electrical systems<\/p>\n<\/li>\n<li>\n<p>Experience working on heavy equipment such as CAT, Komatsu, or similar OEMs preferred<\/p>\n<\/li>\n<li>\n<p>Ability to read and interpret schematics, manuals, and service documentation<\/p>\n<\/li>\n<li>\n<p>Strong troubleshooting and problem-solving skills<\/p>\n<\/li>\n<li>\n<p>Valid driver\u2019s license required<\/p>\n<\/li>\n<\/ul>\n<p><strong>Physical Requirements:<\/strong><\/p>\n<ul>\n<li>\n<p>Ability to lift up to 50 pounds<\/p>\n<\/li>\n<li>\n<p>Ability to work in outdoor environments with exposure to dust, noise, and temperature extremes<\/p>\n<\/li>\n<li>\n<p>Must be able to climb, bend, kneel, and stand for extended periods<\/p>\n<\/li>\n<\/ul>\n<p><strong>Schedule:<\/strong><\/p>\n<ul>\n<li>\n<p>Schedule may include days, nights, weekends, and overtime as required<\/p>\n<\/li>\n<\/ul>\n<p><strong>Safety Commitment:<\/strong><\/p>\n<ul>\n<li>\n<p>Commitment to working safely and complying with MSHA and site-specific safety policies<\/p><\/li><\/ul>","post_title":"Diesel Mechanic","post_link":"https:\/\/turnerstaffing.com\/position\/diesel-mechanic\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Associate","%location_country%":"United States","%location_city%":"Marana","%location_state_id%":"AZ","%location_state_name%":"Arizona","%location_city_state%":"Marana, AZ","%education%":"Unspecified","%department%":"Maintenance","%description%":"<p><strong>Job Title:<\/strong> Diesel Mechanic<br>\n<strong>Location:<\/strong> Marana, AZ<br>\n<strong>Job Type:<\/strong> Full-Time<\/p>\n<p><strong>Job Overview:<\/strong><br>\nTurner Staffing Group is partnered with a mining company in Marana, Arizona that is seeking experienced <strong>Diesel Mechanics<\/strong> to join their maintenance team. This role is responsible for diagnosing, repairing, and maintaining heavy mobile equipment and support equipment to ensure safe and reliable mine operations.<\/p>\n<p><strong>Key Responsibilities:<\/strong><\/p>\n<ul>\n<li>\n<p>Perform preventive maintenance and repairs on heavy mining equipment, including haul trucks, loaders, dozers, excavators, and support equipment<\/p>\n<\/li>\n<li>\n<p>Diagnose mechanical, hydraulic, and electrical issues using appropriate diagnostic tools<\/p>\n<\/li>\n<li>\n<p>Troubleshoot and repair engines, transmissions, braking systems, and hydraulic systems<\/p>\n<\/li>\n<li>\n<p>Conduct inspections to identify wear, damage, or safety concerns<\/p>\n<\/li>\n<li>\n<p>Complete work orders and maintenance documentation accurately and timely<\/p>\n<\/li>\n<li>\n<p>Follow MSHA regulations and company safety procedures at all times<\/p>\n<\/li>\n<li>\n<p>Work closely with operations and maintenance teams to minimize equipment downtime<\/p>\n<\/li>\n<li>\n<p>Maintain a clean and organized work area<\/p>\n<\/li>\n<li>\n<p>Assist with component rebuilds and field repairs as needed<\/p>\n<\/li>\n<\/ul>\n<p><strong>Qualifications:<\/strong><\/p>\n<ul>\n<li>\n<p>High school diploma or GED required; technical or trade school preferred<\/p>\n<\/li>\n<li>\n<p>Minimum of 3\u20135 years of experience as a Diesel Mechanic, preferably in a mining or heavy equipment environment<\/p>\n<\/li>\n<li>\n<p>Strong knowledge of diesel engines, hydraulics, and electrical systems<\/p>\n<\/li>\n<li>\n<p>Experience working on heavy equipment such as CAT, Komatsu, or similar OEMs preferred<\/p>\n<\/li>\n<li>\n<p>Ability to read and interpret schematics, manuals, and service documentation<\/p>\n<\/li>\n<li>\n<p>Strong troubleshooting and problem-solving skills<\/p>\n<\/li>\n<li>\n<p>Valid driver\u2019s license required<\/p>\n<\/li>\n<\/ul>\n<p><strong>Physical Requirements:<\/strong><\/p>\n<ul>\n<li>\n<p>Ability to lift up to 50 pounds<\/p>\n<\/li>\n<li>\n<p>Ability to work in outdoor environments with exposure to dust, noise, and temperature extremes<\/p>\n<\/li>\n<li>\n<p>Must be able to climb, bend, kneel, and stand for extended periods<\/p>\n<\/li>\n<\/ul>\n<p><strong>Schedule:<\/strong><\/p>\n<ul>\n<li>\n<p>Schedule may include days, nights, weekends, and overtime as required<\/p>\n<\/li>\n<\/ul>\n<p><strong>Safety Commitment:<\/strong><\/p>\n<ul>\n<li>\n<p>Commitment to working safely and complying with MSHA and site-specific safety policies<\/p><\/li><\/ul>","%category%":"Other","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/19c9f18b511f-diesel-mechanic","%breezy_id%":"19c9f18b511f","%breezy_friendly_id%":"19c9f18b511f-diesel-mechanic","%breezy_created_date%":"2026-01-21T14:41:00.370Z","%breezy_updated_date%":"2026-01-21T14:52:34.198Z","%_wpgmp_location_city%":"Marana","%_wpgmp_location_state%":"AZ","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Marana, AZ, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"32.436381","%_wpgmp_metabox_longitude%":"-111.2224422","%rank_math_internal_links_processed%":"1"}},"id":3066,"infowindow_disable":false},{"source":"post","title":"Diesel Mechanic","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Diesel Mechanic\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Job Title: Diesel Mechanic Location: Tucson, AZ area Job Type: Full-Time Job Overview: Turner Staffing Group is partnered with a&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/diesel-mechanic-2\/\" name=\"Diesel Mechanic\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Job Title: Diesel Mechanic Location: Tucson, AZ area Job Type: Full-Time Job Overview: Turner Staffing Group is partnered with a&hellip;","address":"Tucson, AZ, USA","location":{"lat":"32.2539787","city":"Tucson","state":"AZ","country":"United States","lng":"-110.9741769","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/diesel-mechanic-2\/","zoom":19,"extra_fields":{"post_excerpt":"Job Title: Diesel Mechanic Location: Tucson, AZ area Job Type: Full-Time Job Overview: Turner Staffing Group is partnered with a&hellip;","post_content":"<p><strong>Job Title:<\/strong> Diesel Mechanic<br>\n<strong>Location:<\/strong> Tucson, AZ area<br>\n<strong>Job Type:<\/strong> Full-Time<\/p>\n<p><strong>Job Overview:<\/strong><br>\nTurner Staffing Group is partnered with a mining company in the Tucson, Arizona area that is seeking experienced <strong>Diesel Mechanics<\/strong> to join their maintenance team. This role is responsible for diagnosing, repairing, and maintaining heavy mobile equipment and support equipment to ensure safe and reliable mine operations.<\/p>\n<p><strong>Key Responsibilities:<\/strong><\/p>\n<ul>\n<li>\n<p>Perform preventive maintenance and repairs on heavy mining equipment, including haul trucks, loaders, dozers, excavators, and support equipment<\/p>\n<\/li>\n<li>\n<p>Diagnose mechanical, hydraulic, and electrical issues using appropriate diagnostic tools<\/p>\n<\/li>\n<li>\n<p>Troubleshoot and repair engines, transmissions, braking systems, and hydraulic systems<\/p>\n<\/li>\n<li>\n<p>Conduct inspections to identify wear, damage, or safety concerns<\/p>\n<\/li>\n<li>\n<p>Complete work orders and maintenance documentation accurately and timely<\/p>\n<\/li>\n<li>\n<p>Follow MSHA regulations and company safety procedures at all times<\/p>\n<\/li>\n<li>\n<p>Work closely with operations and maintenance teams to minimize equipment downtime<\/p>\n<\/li>\n<li>\n<p>Maintain a clean and organized work area<\/p>\n<\/li>\n<li>\n<p>Assist with component rebuilds and field repairs as needed<\/p>\n<\/li>\n<\/ul>\n<p><strong>Qualifications:<\/strong><\/p>\n<ul>\n<li>\n<p>High school diploma or GED required; technical or trade school preferred<\/p>\n<\/li>\n<li>\n<p>Minimum of 3\u20135 years of experience as a Diesel Mechanic, preferably in a mining or heavy equipment environment<\/p>\n<\/li>\n<li>\n<p>Strong knowledge of diesel engines, hydraulics, and electrical systems<\/p>\n<\/li>\n<li>\n<p>Experience working on heavy equipment such as CAT, Komatsu, or similar OEMs preferred<\/p>\n<\/li>\n<li>\n<p>Ability to read and interpret schematics, manuals, and service documentation<\/p>\n<\/li>\n<li>\n<p>Strong troubleshooting and problem-solving skills<\/p>\n<\/li>\n<li>\n<p>Valid driver\u2019s license required<\/p>\n<\/li>\n<\/ul>\n<p><strong>Physical Requirements:<\/strong><\/p>\n<ul>\n<li>\n<p>Ability to lift up to 50 pounds<\/p>\n<\/li>\n<li>\n<p>Ability to work in outdoor environments with exposure to dust, noise, and temperature extremes<\/p>\n<\/li>\n<li>\n<p>Must be able to climb, bend, kneel, and stand for extended periods<\/p>\n<\/li>\n<\/ul>\n<p><strong>Schedule:<\/strong><\/p>\n<ul>\n<li>\n<p>Schedule may include days, nights, weekends, and overtime as required<\/p>\n<\/li>\n<\/ul>\n<p><strong>Safety Commitment:<\/strong><\/p>\n<ul>\n<li>\n<p>Commitment to working safely and complying with MSHA and site-specific safety policies<\/p><\/li><\/ul>","post_title":"Diesel Mechanic","post_link":"https:\/\/turnerstaffing.com\/position\/diesel-mechanic-2\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Associate","%location_country%":"United States","%location_city%":"Tucson","%location_state_id%":"AZ","%location_state_name%":"Arizona","%location_city_state%":"Tucson, AZ","%education%":"Unspecified","%department%":"Maintenance","%description%":"<p><strong>Job Title:<\/strong> Diesel Mechanic<br>\n<strong>Location:<\/strong> Tucson, AZ area<br>\n<strong>Job Type:<\/strong> Full-Time<\/p>\n<p><strong>Job Overview:<\/strong><br>\nTurner Staffing Group is partnered with a mining company in the Tucson, Arizona area that is seeking experienced <strong>Diesel Mechanics<\/strong> to join their maintenance team. This role is responsible for diagnosing, repairing, and maintaining heavy mobile equipment and support equipment to ensure safe and reliable mine operations.<\/p>\n<p><strong>Key Responsibilities:<\/strong><\/p>\n<ul>\n<li>\n<p>Perform preventive maintenance and repairs on heavy mining equipment, including haul trucks, loaders, dozers, excavators, and support equipment<\/p>\n<\/li>\n<li>\n<p>Diagnose mechanical, hydraulic, and electrical issues using appropriate diagnostic tools<\/p>\n<\/li>\n<li>\n<p>Troubleshoot and repair engines, transmissions, braking systems, and hydraulic systems<\/p>\n<\/li>\n<li>\n<p>Conduct inspections to identify wear, damage, or safety concerns<\/p>\n<\/li>\n<li>\n<p>Complete work orders and maintenance documentation accurately and timely<\/p>\n<\/li>\n<li>\n<p>Follow MSHA regulations and company safety procedures at all times<\/p>\n<\/li>\n<li>\n<p>Work closely with operations and maintenance teams to minimize equipment downtime<\/p>\n<\/li>\n<li>\n<p>Maintain a clean and organized work area<\/p>\n<\/li>\n<li>\n<p>Assist with component rebuilds and field repairs as needed<\/p>\n<\/li>\n<\/ul>\n<p><strong>Qualifications:<\/strong><\/p>\n<ul>\n<li>\n<p>High school diploma or GED required; technical or trade school preferred<\/p>\n<\/li>\n<li>\n<p>Minimum of 3\u20135 years of experience as a Diesel Mechanic, preferably in a mining or heavy equipment environment<\/p>\n<\/li>\n<li>\n<p>Strong knowledge of diesel engines, hydraulics, and electrical systems<\/p>\n<\/li>\n<li>\n<p>Experience working on heavy equipment such as CAT, Komatsu, or similar OEMs preferred<\/p>\n<\/li>\n<li>\n<p>Ability to read and interpret schematics, manuals, and service documentation<\/p>\n<\/li>\n<li>\n<p>Strong troubleshooting and problem-solving skills<\/p>\n<\/li>\n<li>\n<p>Valid driver\u2019s license required<\/p>\n<\/li>\n<\/ul>\n<p><strong>Physical Requirements:<\/strong><\/p>\n<ul>\n<li>\n<p>Ability to lift up to 50 pounds<\/p>\n<\/li>\n<li>\n<p>Ability to work in outdoor environments with exposure to dust, noise, and temperature extremes<\/p>\n<\/li>\n<li>\n<p>Must be able to climb, bend, kneel, and stand for extended periods<\/p>\n<\/li>\n<\/ul>\n<p><strong>Schedule:<\/strong><\/p>\n<ul>\n<li>\n<p>Schedule may include days, nights, weekends, and overtime as required<\/p>\n<\/li>\n<\/ul>\n<p><strong>Safety Commitment:<\/strong><\/p>\n<ul>\n<li>\n<p>Commitment to working safely and complying with MSHA and site-specific safety policies<\/p><\/li><\/ul>","%category%":"Other","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/cbfa4b4fd8aa-diesel-mechanic","%breezy_id%":"cbfa4b4fd8aa","%breezy_friendly_id%":"cbfa4b4fd8aa-diesel-mechanic","%breezy_created_date%":"2026-01-21T14:45:28.682Z","%breezy_updated_date%":"2026-01-21T14:46:06.952Z","%_wpgmp_location_city%":"Tucson","%_wpgmp_location_state%":"AZ","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Tucson, AZ, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"32.2539787","%_wpgmp_metabox_longitude%":"-110.9741769","%rank_math_internal_links_processed%":"1"}},"id":3067,"infowindow_disable":false},{"source":"post","title":"Entry Level Miner","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Entry Level Miner\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Entry Level Miner &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; Reports to:&nbsp;Foreman \u2013 Turner Mining Group Job Description: The Entry Level Miner is a starting point&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/entry-level-miner-2\/\" name=\"Entry Level Miner\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Entry Level Miner &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; Reports to:&nbsp;Foreman \u2013 Turner Mining Group Job Description: The Entry Level Miner is a starting point&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\/entry-level-miner-2\/","zoom":19,"extra_fields":{"post_excerpt":"Entry Level Miner &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; Reports to:&nbsp;Foreman \u2013 Turner Mining Group Job Description: The Entry Level Miner is a starting point&hellip;","post_content":"<p><strong>Entry Level Miner<\/strong>        &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&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><strong>Reports to:&nbsp;<\/strong><strong>Foreman \u2013 Turner Mining Group<\/strong><\/p>\n<p><strong>Job Description:<\/strong><\/p>\n<p>The Entry Level Miner is a starting point for both operations and maintenance within Turner Mining Group. This position will develop into a Production Miner or Fuel \/ Lube Technician role. The successful candidate must live the Turner Values and be an outward example to others. This position must demonstrate a strong commitment to \u201cSafe Production\u201d through decision making, priorities, and client relations.<\/p>\n<p><strong>Objectives and Contributions:<\/strong><\/p>\n<p>The Entry Level Miner is focused on key aspects that drive communication and safe production while maintaining a high level of efficiency, and preventative maintenance awareness requirements. The Entry Level Miner demonstrates safety ownership at a personal level and holds other crew members to the same high standard.<\/p>\n<ul><li>Work with employees to ensure a high level of accuracy and engagement on hazard identification and control<\/li><li>Engage crews and leadership to define processes that motivate working towards common goals<\/li><li>Assist with MSHA regulatory task training and verify compliance to standards<\/li><li>Live the values as part of a visible daily decision-making process<\/li><li>Involvement in risk assessment processes at various levels of the organization<\/li><li>Holds themselves and others accountable for acting like an owner (taking care of equipment, not wasting resources, using time wisely, and being accountable for conditions and behaviors)<\/li><li>Maintains a high standard of housekeeping (machine and work areas)<\/li><\/ul>\n<p><u>Culture and Communication:<\/u><\/p>\n<ul><li>Can effectively communicate in English (multi-lingual preferred)<\/li><li>Work with crews to support proactive near miss reporting<\/li><li>Leads by example (walks the talk)<\/li><\/ul>\n<p><u>Systems:<\/u><\/p>\n<ul><li>Trains to Turner standards to perform quality pre-operation machine inspections (Based on mobile equipment physical demands analysis)<\/li><li>Trains to Turner standards to accurately document 5000-23 and training checklist requirements<\/li><li>Other regulatory &amp; internal \/ external forms as required<\/li><li>Maintains a valid and insurable driving license<\/li><\/ul>\n<p><u>Travel and New Site Development:<\/u><\/p>\n<p><u>Time and Interactions:<\/u><\/p>\n<ul><li>The Entry Level Miner must be flexible on shift schedules (days and nights) to assist with training and production needs<\/li><li>The Entry Level Miner will be self-starting, motivated, with a strong desire to be part of a team and to influence improvement. Communication is also critical to keep leadership and site-based personnel in the loop of successes, challenges, and any additional support that may be required<\/li><li>Excellent time management skills<\/li><\/ul>\n<p><u>Qualifications:<\/u><\/p>\n<ul><li>Willingness and ability to adhere to OSHA \/ MSHA regulatory requirements<\/li><li>Entry Level Miners will be subject to a probationary period of six months from the date of hire<\/li><li>0-1 years\u2019 experience in mining \/ heavy industry preferred<\/li><li>Ability to obtain a working knowledge of safety systems and processes<\/li><li>Appropriate attention to detail required<\/li><li>Strong communication skills<\/li><li>Strong morals and values<\/li><li>Exemplary attendance record<\/li><li>Exemplary safety and disciplinary record<\/li><li>Willingness to be flexible on daily job duty requirements<\/li><li>Maintains a positive outspoken learning attitude<\/li><\/ul>\n<ul><li>The Entry Level Miner will become competent and highly proficient on each piece of the following equipment through on-the-job training and skills qualification<ul><li><strong>Water truck<\/strong><\/li><li><strong>Haulage Truc<\/strong><strong>k<\/strong><\/li><li><strong>OR<\/strong><\/li><li><strong>Preventative Maintenance<\/strong><\/li><li><strong>Fuel \/ Lube Truck<\/strong><\/li><\/ul><\/li><\/ul>\n<p><u>Other Duties:<\/u><\/p>\n<ul><li>In addition to the job skills above, there may be requirements for manual tasks to be completed to meet other business needs. Operators in any job duty classification may be required to participate in these additional tasks.<\/li><\/ul>\n<p><u><strong>Benefits<\/strong><\/u><br>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. 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>\n<p><\/p>","post_title":"Entry Level Miner","post_link":"https:\/\/turnerstaffing.com\/position\/entry-level-miner-2\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Entry Level","%location_country%":"United States","%location_city%":"Ely","%location_state_id%":"NV","%location_state_name%":"Nevada","%location_city_state%":"Ely, NV","%education%":"Unspecified","%department%":"Operations","%description%":"<p><strong>Entry Level Miner<\/strong>        &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&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><strong>Reports to:&nbsp;<\/strong><strong>Foreman \u2013 Turner Mining Group<\/strong><\/p>\n<p><strong>Job Description:<\/strong><\/p>\n<p>The Entry Level Miner is a starting point for both operations and maintenance within Turner Mining Group. This position will develop into a Production Miner or Fuel \/ Lube Technician role. The successful candidate must live the Turner Values and be an outward example to others. This position must demonstrate a strong commitment to \u201cSafe Production\u201d through decision making, priorities, and client relations.<\/p>\n<p><strong>Objectives and Contributions:<\/strong><\/p>\n<p>The Entry Level Miner is focused on key aspects that drive communication and safe production while maintaining a high level of efficiency, and preventative maintenance awareness requirements. The Entry Level Miner demonstrates safety ownership at a personal level and holds other crew members to the same high standard.<\/p>\n<ul><li>Work with employees to ensure a high level of accuracy and engagement on hazard identification and control<\/li><li>Engage crews and leadership to define processes that motivate working towards common goals<\/li><li>Assist with MSHA regulatory task training and verify compliance to standards<\/li><li>Live the values as part of a visible daily decision-making process<\/li><li>Involvement in risk assessment processes at various levels of the organization<\/li><li>Holds themselves and others accountable for acting like an owner (taking care of equipment, not wasting resources, using time wisely, and being accountable for conditions and behaviors)<\/li><li>Maintains a high standard of housekeeping (machine and work areas)<\/li><\/ul>\n<p><u>Culture and Communication:<\/u><\/p>\n<ul><li>Can effectively communicate in English (multi-lingual preferred)<\/li><li>Work with crews to support proactive near miss reporting<\/li><li>Leads by example (walks the talk)<\/li><\/ul>\n<p><u>Systems:<\/u><\/p>\n<ul><li>Trains to Turner standards to perform quality pre-operation machine inspections (Based on mobile equipment physical demands analysis)<\/li><li>Trains to Turner standards to accurately document 5000-23 and training checklist requirements<\/li><li>Other regulatory &amp; internal \/ external forms as required<\/li><li>Maintains a valid and insurable driving license<\/li><\/ul>\n<p><u>Travel and New Site Development:<\/u><\/p>\n<p><u>Time and Interactions:<\/u><\/p>\n<ul><li>The Entry Level Miner must be flexible on shift schedules (days and nights) to assist with training and production needs<\/li><li>The Entry Level Miner will be self-starting, motivated, with a strong desire to be part of a team and to influence improvement. Communication is also critical to keep leadership and site-based personnel in the loop of successes, challenges, and any additional support that may be required<\/li><li>Excellent time management skills<\/li><\/ul>\n<p><u>Qualifications:<\/u><\/p>\n<ul><li>Willingness and ability to adhere to OSHA \/ MSHA regulatory requirements<\/li><li>Entry Level Miners will be subject to a probationary period of six months from the date of hire<\/li><li>0-1 years\u2019 experience in mining \/ heavy industry preferred<\/li><li>Ability to obtain a working knowledge of safety systems and processes<\/li><li>Appropriate attention to detail required<\/li><li>Strong communication skills<\/li><li>Strong morals and values<\/li><li>Exemplary attendance record<\/li><li>Exemplary safety and disciplinary record<\/li><li>Willingness to be flexible on daily job duty requirements<\/li><li>Maintains a positive outspoken learning attitude<\/li><\/ul>\n<ul><li>The Entry Level Miner will become competent and highly proficient on each piece of the following equipment through on-the-job training and skills qualification<ul><li><strong>Water truck<\/strong><\/li><li><strong>Haulage Truc<\/strong><strong>k<\/strong><\/li><li><strong>OR<\/strong><\/li><li><strong>Preventative Maintenance<\/strong><\/li><li><strong>Fuel \/ Lube Truck<\/strong><\/li><\/ul><\/li><\/ul>\n<p><u>Other Duties:<\/u><\/p>\n<ul><li>In addition to the job skills above, there may be requirements for manual tasks to be completed to meet other business needs. Operators in any job duty classification may be required to participate in these additional tasks.<\/li><\/ul>\n<p><u><strong>Benefits<\/strong><\/u><br>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. 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>\n<p><\/p>","%category%":"Operations","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/d15cd0bfb899-entry-level-miner","%breezy_id%":"d15cd0bfb899","%breezy_friendly_id%":"d15cd0bfb899-entry-level-miner","%breezy_created_date%":"2026-01-21T17:39:43.117Z","%breezy_updated_date%":"2026-01-21T17:40:07.795Z","%_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":3068,"infowindow_disable":false},{"source":"post","title":"Production Miner &#8211; Haul Truck","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Production Miner &#8211; Haul Truck\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Production Miner &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; Reports to: Foreman \u2013 Turner Mining Group Job Description: The Production Miner is a developing mining operator&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/production-miner-haul-truck-2\/\" name=\"Production Miner &#8211; Haul Truck\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Production Miner &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; Reports to: Foreman \u2013 Turner Mining Group Job Description: The Production Miner is a developing mining operator&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\/production-miner-haul-truck-2\/","zoom":19,"extra_fields":{"post_excerpt":"Production Miner &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; Reports to: Foreman \u2013 Turner Mining Group Job Description: The Production Miner is a developing mining operator&hellip;","post_content":"<p><strong>Production Miner<\/strong>                &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&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><strong>Reports to: <\/strong><strong>Foreman \u2013 Turner Mining Group<\/strong><\/p>\n<p><strong>Job Description:<\/strong><\/p>\n<p>The Production Miner is a developing mining operator position within Turner Mining Group. The successful candidate must live the Turner Values and be an outward example to others. This position must demonstrate a strong commitment to \u201cSafe Production\u201d through decision making, priorities, and client relations.<\/p>\n<p><strong>Objectives and Contributions:<\/strong><\/p>\n<p>The Production Miner is focused on key aspects that drive communication and safe production while maintaining a high level of efficiency, and preventative maintenance awareness requirements. The Production Miner demonstrates safety ownership at a personal level and holds other crew members to the same high standard.&nbsp; The Production Miner will train and develop into the Equipment Operator job scope while the Equipment operator is filling in for the Senior job duties.<\/p>\n<ul><li>Work with employees to ensure a high level of accuracy and engagement on hazard identification and control<\/li><li>Engage crews and leadership to define processes that motivate working towards common goals<\/li><li>Assist with MSHA regulatory task training and verify compliance to standards<\/li><li>Live the values as part of a visible daily decision-making process<\/li><li>Assist with training proficiency audits<\/li><li>Involvement in risk assessment processes at various levels of the organization<\/li><li>Holds themselves and others accountable for acting like an owner (taking care of equipment, not wasting resources, using time wisely, and being accountable for conditions and behaviors)<\/li><li>Maintains a high standard of housekeeping (machine and work areas)<\/li><\/ul>\n<p><u>Culture and Communication:<\/u><\/p>\n<ul><li>Can effectively communicate in English (multi-lingual preferred)<\/li><li>Participate in site and project leaders to identify areas of improvement<\/li><li>Work with crews to support proactive near miss reporting<\/li><li>Leads by example (walks the talk)<\/li><\/ul>\n<p><u>Systems:<\/u><\/p>\n<ul><li>Ability to perform quality pre-operation machine inspections (Based on mobile equipment physical demands analysis)<\/li><li>Accurately documents 5000-23 and training checklist requirements<\/li><li>Other regulatory &amp; internal \/ external forms as required<\/li><li>Maintains a valid and insurable driving license<\/li><\/ul>\n<p><u>Travel and New Site Development: <\/u><\/p>\n<p><u>Time and Interactions:<\/u><\/p>\n<ul><li>The Production Miner must be flexible on shift schedules (days and nights) to assist with training and production needs<\/li><li>The Production Miner will be self-starting, motivated, with a strong desire to be part of a team and to influence improvement. Communication is also critical to keep leadership and site-based personnel in the loop of successes, challenges, and any additional support that may be required<\/li><li>Excellent time management skills<\/li><\/ul>\n<p><u>Qualifications:<\/u><\/p>\n<ul><li>Willingness and ability to adhere to OSHA \/ MSHA regulatory requirements<\/li><li>Production Miner will be subject to a probationary period of six months from the date of hire<\/li><li>0-2 years\u2019 experience in mining \/ heavy industry preferred<\/li><li>Working knowledge of safety systems and processes<\/li><li>Appropriate attention to detail required<\/li><li>Strong communication skills<\/li><li>Strong morals and values<\/li><li>Exemplary attendance record<\/li><li>Exemplary safety and disciplinary record<\/li><li>Willingness to be flexible on daily job duty requirements<\/li><li>Maintains a positive outspoken learning attitude<\/li><li>The Production Miner will be competent and highly proficient on each piece of the following equipment: <ul><li><strong>Water truck, <\/strong><\/li><li><strong>Haulage Truck<\/strong><\/li><\/ul><\/li><\/ul>\n<p><strong><u>Other Duties:<\/u><br><\/strong><\/p>\n<ul><li>In addition to the job skills above, there may be requirements for manual tasks to be completed to meet other business needs. Operators in any job duty classification may be required to participate in these additional tasks.<u><\/u><\/li><\/ul>","post_title":"Production Miner &#8211; Haul Truck","post_link":"https:\/\/turnerstaffing.com\/position\/production-miner-haul-truck-2\/","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%":"Unspecified","%department%":"Operations","%description%":"<p><strong>Production Miner<\/strong>                &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&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><strong>Reports to: <\/strong><strong>Foreman \u2013 Turner Mining Group<\/strong><\/p>\n<p><strong>Job Description:<\/strong><\/p>\n<p>The Production Miner is a developing mining operator position within Turner Mining Group. The successful candidate must live the Turner Values and be an outward example to others. This position must demonstrate a strong commitment to \u201cSafe Production\u201d through decision making, priorities, and client relations.<\/p>\n<p><strong>Objectives and Contributions:<\/strong><\/p>\n<p>The Production Miner is focused on key aspects that drive communication and safe production while maintaining a high level of efficiency, and preventative maintenance awareness requirements. The Production Miner demonstrates safety ownership at a personal level and holds other crew members to the same high standard.&nbsp; The Production Miner will train and develop into the Equipment Operator job scope while the Equipment operator is filling in for the Senior job duties.<\/p>\n<ul><li>Work with employees to ensure a high level of accuracy and engagement on hazard identification and control<\/li><li>Engage crews and leadership to define processes that motivate working towards common goals<\/li><li>Assist with MSHA regulatory task training and verify compliance to standards<\/li><li>Live the values as part of a visible daily decision-making process<\/li><li>Assist with training proficiency audits<\/li><li>Involvement in risk assessment processes at various levels of the organization<\/li><li>Holds themselves and others accountable for acting like an owner (taking care of equipment, not wasting resources, using time wisely, and being accountable for conditions and behaviors)<\/li><li>Maintains a high standard of housekeeping (machine and work areas)<\/li><\/ul>\n<p><u>Culture and Communication:<\/u><\/p>\n<ul><li>Can effectively communicate in English (multi-lingual preferred)<\/li><li>Participate in site and project leaders to identify areas of improvement<\/li><li>Work with crews to support proactive near miss reporting<\/li><li>Leads by example (walks the talk)<\/li><\/ul>\n<p><u>Systems:<\/u><\/p>\n<ul><li>Ability to perform quality pre-operation machine inspections (Based on mobile equipment physical demands analysis)<\/li><li>Accurately documents 5000-23 and training checklist requirements<\/li><li>Other regulatory &amp; internal \/ external forms as required<\/li><li>Maintains a valid and insurable driving license<\/li><\/ul>\n<p><u>Travel and New Site Development: <\/u><\/p>\n<p><u>Time and Interactions:<\/u><\/p>\n<ul><li>The Production Miner must be flexible on shift schedules (days and nights) to assist with training and production needs<\/li><li>The Production Miner will be self-starting, motivated, with a strong desire to be part of a team and to influence improvement. Communication is also critical to keep leadership and site-based personnel in the loop of successes, challenges, and any additional support that may be required<\/li><li>Excellent time management skills<\/li><\/ul>\n<p><u>Qualifications:<\/u><\/p>\n<ul><li>Willingness and ability to adhere to OSHA \/ MSHA regulatory requirements<\/li><li>Production Miner will be subject to a probationary period of six months from the date of hire<\/li><li>0-2 years\u2019 experience in mining \/ heavy industry preferred<\/li><li>Working knowledge of safety systems and processes<\/li><li>Appropriate attention to detail required<\/li><li>Strong communication skills<\/li><li>Strong morals and values<\/li><li>Exemplary attendance record<\/li><li>Exemplary safety and disciplinary record<\/li><li>Willingness to be flexible on daily job duty requirements<\/li><li>Maintains a positive outspoken learning attitude<\/li><li>The Production Miner will be competent and highly proficient on each piece of the following equipment: <ul><li><strong>Water truck, <\/strong><\/li><li><strong>Haulage Truck<\/strong><\/li><\/ul><\/li><\/ul>\n<p><strong><u>Other Duties:<\/u><br><\/strong><\/p>\n<ul><li>In addition to the job skills above, there may be requirements for manual tasks to be completed to meet other business needs. Operators in any job duty classification may be required to participate in these additional tasks.<u><\/u><\/li><\/ul>","%category%":"Operations","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/2ba8dd53a5b0-production-miner-haul-truck","%breezy_id%":"2ba8dd53a5b0","%breezy_friendly_id%":"2ba8dd53a5b0-production-miner-haul-truck","%breezy_created_date%":"2026-01-21T17:42:52.949Z","%breezy_updated_date%":"2026-01-27T18:51:51.910Z","%_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":3069,"infowindow_disable":false},{"source":"post","title":"Lead Estimator- Heavy Civil Construction","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Lead Estimator- Heavy Civil Construction\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Job Title: Lead Estimator \u2013 Heavy Civil Construction Location: Tulsa, OK (Must reside within a 40-mile radius of Tulsa) Company:&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/lead-estimator-heavy-civil-construction\/\" name=\"Lead Estimator- Heavy Civil Construction\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Job Title: Lead Estimator \u2013 Heavy Civil Construction Location: Tulsa, OK (Must reside within a 40-mile radius of Tulsa) Company:&hellip;","address":"Tulsa, OK, USA","location":{"lat":"36.1551375","city":"Tulsa","state":"OK","country":"United States","lng":"-95.989501","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/lead-estimator-heavy-civil-construction\/","zoom":19,"extra_fields":{"post_excerpt":"Job Title: Lead Estimator \u2013 Heavy Civil Construction Location: Tulsa, OK (Must reside within a 40-mile radius of Tulsa) Company:&hellip;","post_content":"<h2>Job Title: Lead Estimator \u2013 Heavy Civil Construction<\/h2>\n<p><strong>Location:<\/strong> Tulsa, OK (Must reside within a 40-mile radius of Tulsa)<br>\n<strong>Company:<\/strong> Turner Staffing Group<br>\n<strong>Work Arrangement:<\/strong> Hybrid \/ Remote (80\u201385% remote; 15\u201320% job site travel)<\/p>\n<h3>Position Overview<\/h3>\n<p>Turner Staffing Group is seeking an experienced <strong>Lead Estimator<\/strong> to support and lead estimating efforts for heavy civil construction projects throughout the private, public, and municipal sectors. This role focuses on <strong>wet utilities, mass excavation, land clearing, and site development<\/strong> and plays a critical role in securing profitable work by producing accurate, competitive bids.<\/p>\n<p>The Lead Estimator will work remotely the majority of the time, with periodic travel to job sites for pre-bid walks, site evaluations, and coordination with project teams. Candidates must currently live within a <strong>40-mile radius of Tulsa, Oklahoma<\/strong>.<\/p>\n<h3>Key Responsibilities<\/h3>\n<ul>\n<li>\n<p>Lead and manage the estimating process for heavy civil construction projects from initial review through final bid submission<\/p>\n<\/li>\n<li>\n<p>Prepare detailed cost estimates for wet utilities, mass excavation, land clearing, grading, and full site development scopes<\/p>\n<\/li>\n<li>\n<p>Review plans, specifications, and geotechnical reports to determine accurate quantities, labor, equipment, and material costs<\/p>\n<\/li>\n<li>\n<p>Solicit, evaluate, and negotiate subcontractor and supplier pricing<\/p>\n<\/li>\n<li>\n<p>Conduct site visits and pre-bid walkthroughs to assess site conditions, logistics, and risk<\/p>\n<\/li>\n<li>\n<p>Develop bid strategies and pricing approaches to remain competitive while protecting margins<\/p>\n<\/li>\n<li>\n<p>Coordinate with operations, project management, and leadership to align estimates with execution plans<\/p>\n<\/li>\n<li>\n<p>Identify potential risks and opportunities and incorporate them into estimates and proposals<\/p>\n<\/li>\n<li>\n<p>Maintain estimating databases, historical cost data, and bid tracking records<\/p>\n<\/li>\n<li>\n<p>Support post-bid reviews, handoffs to operations, and project buyout as needed<\/p>\n<\/li>\n<\/ul>\n<h3>Required Qualifications<\/h3>\n<ul>\n<li>\n<p>Minimum <strong>7\u201310 years<\/strong> of estimating experience in heavy civil construction<\/p>\n<\/li>\n<li>\n<p>Proven experience estimating <strong>wet utilities, mass excavation, land clearing, and site development<\/strong> projects<\/p>\n<\/li>\n<li>\n<p>Strong understanding of private, public, and municipal bidding processes<\/p>\n<\/li>\n<li>\n<p>Proficiency with construction estimating software and takeoff tools (e.g., HCSS, Bluebeam, Agtek, Trimble, or similar)<\/p>\n<\/li>\n<li>\n<p>Ability to read and interpret civil plans, specifications, and contracts<\/p>\n<\/li>\n<li>\n<p>Strong analytical, organizational, and time-management skills<\/p>\n<\/li>\n<li>\n<p>Excellent written and verbal communication skills<\/p>\n<\/li>\n<li>\n<p>Ability to work independently in a remote environment while collaborating effectively with teams<\/p>\n<\/li>\n<li>\n<p>Valid driver\u2019s license and willingness to travel to job sites as required (15\u201320%)<\/p>\n<\/li>\n<\/ul>\n<h3>Location &amp; Travel Requirements<\/h3>\n<ul>\n<li>\n<p><strong>Must currently reside within a 40-mile radius of Tulsa, OK<\/strong><\/p>\n<\/li>\n<li>\n<p>Position is <strong>80\u201385% remote<\/strong>, with <strong>15\u201320% travel<\/strong> to job sites for site visits and meetings<\/p>\n<\/li>\n<\/ul>\n<h3>Preferred Qualifications<\/h3>\n<ul>\n<li>\n<p>Experience leading or mentoring junior estimators<\/p>\n<\/li>\n<li>\n<p>Familiarity with DOT, municipal, or public works projects<\/p>\n<\/li>\n<li>\n<p>Civil construction field experience or operations background<\/p>\n<\/li>\n<li>\n<p>Bachelor\u2019s degree in Construction Management, Civil Engineering, or a related field<\/p>\n<\/li>\n<\/ul>\n<h3>What Turner Staffing Group Offers<\/h3>\n<ul>\n<li>\n<p>Competitive compensation based on experience<\/p>\n<\/li>\n<li>\n<p>Hybrid\/remote work flexibility<\/p>\n<\/li>\n<li>\n<p>Opportunity to work on diverse and complex heavy civil projects<\/p>\n<\/li>\n<li>\n<p>Supportive, growth-oriented company culture<\/p><\/li><\/ul>","post_title":"Lead Estimator- Heavy Civil Construction","post_link":"https:\/\/turnerstaffing.com\/position\/lead-estimator-heavy-civil-construction\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Senior","%location_country%":"United States","%location_city%":"Tulsa","%location_state_id%":"OK","%location_state_name%":"Oklahoma","%location_city_state%":"Tulsa, OK","%education%":"Unspecified","%department%":"","%description%":"<h2>Job Title: Lead Estimator \u2013 Heavy Civil Construction<\/h2>\n<p><strong>Location:<\/strong> Tulsa, OK (Must reside within a 40-mile radius of Tulsa)<br>\n<strong>Company:<\/strong> Turner Staffing Group<br>\n<strong>Work Arrangement:<\/strong> Hybrid \/ Remote (80\u201385% remote; 15\u201320% job site travel)<\/p>\n<h3>Position Overview<\/h3>\n<p>Turner Staffing Group is seeking an experienced <strong>Lead Estimator<\/strong> to support and lead estimating efforts for heavy civil construction projects throughout the private, public, and municipal sectors. This role focuses on <strong>wet utilities, mass excavation, land clearing, and site development<\/strong> and plays a critical role in securing profitable work by producing accurate, competitive bids.<\/p>\n<p>The Lead Estimator will work remotely the majority of the time, with periodic travel to job sites for pre-bid walks, site evaluations, and coordination with project teams. Candidates must currently live within a <strong>40-mile radius of Tulsa, Oklahoma<\/strong>.<\/p>\n<h3>Key Responsibilities<\/h3>\n<ul>\n<li>\n<p>Lead and manage the estimating process for heavy civil construction projects from initial review through final bid submission<\/p>\n<\/li>\n<li>\n<p>Prepare detailed cost estimates for wet utilities, mass excavation, land clearing, grading, and full site development scopes<\/p>\n<\/li>\n<li>\n<p>Review plans, specifications, and geotechnical reports to determine accurate quantities, labor, equipment, and material costs<\/p>\n<\/li>\n<li>\n<p>Solicit, evaluate, and negotiate subcontractor and supplier pricing<\/p>\n<\/li>\n<li>\n<p>Conduct site visits and pre-bid walkthroughs to assess site conditions, logistics, and risk<\/p>\n<\/li>\n<li>\n<p>Develop bid strategies and pricing approaches to remain competitive while protecting margins<\/p>\n<\/li>\n<li>\n<p>Coordinate with operations, project management, and leadership to align estimates with execution plans<\/p>\n<\/li>\n<li>\n<p>Identify potential risks and opportunities and incorporate them into estimates and proposals<\/p>\n<\/li>\n<li>\n<p>Maintain estimating databases, historical cost data, and bid tracking records<\/p>\n<\/li>\n<li>\n<p>Support post-bid reviews, handoffs to operations, and project buyout as needed<\/p>\n<\/li>\n<\/ul>\n<h3>Required Qualifications<\/h3>\n<ul>\n<li>\n<p>Minimum <strong>7\u201310 years<\/strong> of estimating experience in heavy civil construction<\/p>\n<\/li>\n<li>\n<p>Proven experience estimating <strong>wet utilities, mass excavation, land clearing, and site development<\/strong> projects<\/p>\n<\/li>\n<li>\n<p>Strong understanding of private, public, and municipal bidding processes<\/p>\n<\/li>\n<li>\n<p>Proficiency with construction estimating software and takeoff tools (e.g., HCSS, Bluebeam, Agtek, Trimble, or similar)<\/p>\n<\/li>\n<li>\n<p>Ability to read and interpret civil plans, specifications, and contracts<\/p>\n<\/li>\n<li>\n<p>Strong analytical, organizational, and time-management skills<\/p>\n<\/li>\n<li>\n<p>Excellent written and verbal communication skills<\/p>\n<\/li>\n<li>\n<p>Ability to work independently in a remote environment while collaborating effectively with teams<\/p>\n<\/li>\n<li>\n<p>Valid driver\u2019s license and willingness to travel to job sites as required (15\u201320%)<\/p>\n<\/li>\n<\/ul>\n<h3>Location &amp; Travel Requirements<\/h3>\n<ul>\n<li>\n<p><strong>Must currently reside within a 40-mile radius of Tulsa, OK<\/strong><\/p>\n<\/li>\n<li>\n<p>Position is <strong>80\u201385% remote<\/strong>, with <strong>15\u201320% travel<\/strong> to job sites for site visits and meetings<\/p>\n<\/li>\n<\/ul>\n<h3>Preferred Qualifications<\/h3>\n<ul>\n<li>\n<p>Experience leading or mentoring junior estimators<\/p>\n<\/li>\n<li>\n<p>Familiarity with DOT, municipal, or public works projects<\/p>\n<\/li>\n<li>\n<p>Civil construction field experience or operations background<\/p>\n<\/li>\n<li>\n<p>Bachelor\u2019s degree in Construction Management, Civil Engineering, or a related field<\/p>\n<\/li>\n<\/ul>\n<h3>What Turner Staffing Group Offers<\/h3>\n<ul>\n<li>\n<p>Competitive compensation based on experience<\/p>\n<\/li>\n<li>\n<p>Hybrid\/remote work flexibility<\/p>\n<\/li>\n<li>\n<p>Opportunity to work on diverse and complex heavy civil projects<\/p>\n<\/li>\n<li>\n<p>Supportive, growth-oriented company culture<\/p><\/li><\/ul>","%category%":"Sales","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/5a94767aa391-lead-estimator-heavy-civil-construction","%breezy_id%":"5a94767aa391","%breezy_friendly_id%":"5a94767aa391-lead-estimator-heavy-civil-construction","%breezy_created_date%":"2026-01-21T14:30:39.813Z","%breezy_updated_date%":"2026-01-21T14:31:31.894Z","%_wpgmp_location_city%":"Tulsa","%_wpgmp_location_state%":"OK","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Tulsa, OK, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"36.1551375","%_wpgmp_metabox_longitude%":"-95.989501","%rank_math_internal_links_processed%":"1"}},"id":3064,"infowindow_disable":false},{"source":"post","title":"Field Superintendent- Heavy Civil","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Field Superintendent- Heavy Civil\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Job Title: Field Superintendent \u2013 Heavy Civil Construction Location: Tulsa, OK (Must reside within a 40-mile radius) Company: Turner Staffing&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/field-superintendent-heavy-civil\/\" name=\"Field Superintendent- Heavy Civil\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Job Title: Field Superintendent \u2013 Heavy Civil Construction Location: Tulsa, OK (Must reside within a 40-mile radius) Company: Turner Staffing&hellip;","address":"Tulsa, OK, USA","location":{"lat":"36.1551375","city":"Tulsa","state":"OK","country":"United States","lng":"-95.989501","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/field-superintendent-heavy-civil\/","zoom":19,"extra_fields":{"post_excerpt":"Job Title: Field Superintendent \u2013 Heavy Civil Construction Location: Tulsa, OK (Must reside within a 40-mile radius) Company: Turner Staffing&hellip;","post_content":"<h2>Job Title: Field Superintendent \u2013 Heavy Civil Construction<\/h2>\n<p><strong>Location:<\/strong> Tulsa, OK (Must reside within a 40-mile radius)<br>\n<strong>Company:<\/strong> Turner Staffing Group<br>\n<strong>Work Environment:<\/strong> 100% On-Site \/ Field-Based<\/p>\n<h3>Position Overview<\/h3>\n<p>Turner Staffing Group is seeking an experienced <strong>Field Superintendent<\/strong> to oversee and manage daily field operations for heavy civil construction projects across the private, public, and municipal sectors. This role is fully on-site and requires regular travel to active job sites in and around the Tulsa area.<\/p>\n<p>The Field Superintendent will be responsible for supervising crews, coordinating subcontractors, maintaining safety and quality standards, and ensuring projects involving <strong>wet utilities, mass excavation, land clearing, and site development<\/strong> are executed safely, efficiently, and in accordance with project plans and schedules.<\/p>\n<h3>Key Responsibilities<\/h3>\n<ul>\n<li>\n<p>Manage day-to-day field operations on heavy civil construction projects<\/p>\n<\/li>\n<li>\n<p>Supervise field crews, foremen, and subcontractors to ensure productivity and quality standards are met<\/p>\n<\/li>\n<li>\n<p>Oversee construction activities related to wet utilities, mass excavation, land clearing, grading, and full site development<\/p>\n<\/li>\n<li>\n<p>Interpret and execute work per project plans, specifications, and schedules<\/p>\n<\/li>\n<li>\n<p>Coordinate manpower, equipment, and materials to maintain efficient operations<\/p>\n<\/li>\n<li>\n<p>Ensure strict compliance with safety regulations, company policies, and site-specific safety plans<\/p>\n<\/li>\n<li>\n<p>Conduct daily jobsite inspections, safety meetings, and toolbox talks<\/p>\n<\/li>\n<li>\n<p>Communicate project progress, issues, and needs to project managers and leadership<\/p>\n<\/li>\n<li>\n<p>Monitor production rates, track progress, and assist with short- and long-term planning<\/p>\n<\/li>\n<li>\n<p>Identify and resolve field issues, constructability challenges, and sequencing conflicts<\/p>\n<\/li>\n<li>\n<p>Maintain accurate daily reports, logs, and documentation<\/p>\n<\/li>\n<li>\n<p>Participate in preconstruction meetings, jobsite meetings, and inspections as required<\/p>\n<\/li>\n<\/ul>\n<h3>Required Qualifications<\/h3>\n<ul>\n<li>\n<p>Minimum <strong>7\u201310 years<\/strong> of field supervision experience in heavy civil construction<\/p>\n<\/li>\n<li>\n<p>Proven experience overseeing <strong>wet utilities, mass excavation, land clearing, and site development<\/strong> projects<\/p>\n<\/li>\n<li>\n<p>Strong knowledge of private, public, and municipal construction standards and practices<\/p>\n<\/li>\n<li>\n<p>Ability to read and interpret civil construction plans, specifications, and schedules<\/p>\n<\/li>\n<li>\n<p>Solid understanding of heavy equipment operations and earthwork production<\/p>\n<\/li>\n<li>\n<p>Strong leadership, communication, and problem-solving skills<\/p>\n<\/li>\n<li>\n<p>Commitment to safety-first construction practices<\/p>\n<\/li>\n<li>\n<p>Ability to work in a fast-paced, field-based environment<\/p>\n<\/li>\n<li>\n<p>Valid driver\u2019s license and reliable transportation<\/p>\n<\/li>\n<li>\n<p><strong>Must currently reside within a 40-mile radius of Tulsa, OK<\/strong><\/p>\n<\/li>\n<\/ul>\n<h3>Preferred Qualifications<\/h3>\n<ul>\n<li>\n<p>Experience supervising multiple crews and subcontractors simultaneously<\/p>\n<\/li>\n<li>\n<p>Familiarity with DOT, municipal, or public works projects<\/p>\n<\/li>\n<li>\n<p>OSHA 30 certification (or ability to obtain)<\/p>\n<\/li>\n<li>\n<p>Background in civil construction operations or trade experience<\/p>\n<\/li>\n<\/ul>\n<h3>Physical &amp; Work Environment Requirements<\/h3>\n<ul>\n<li>\n<p>Ability to work outdoors in varying weather conditions<\/p>\n<\/li>\n<li>\n<p>Ability to walk job sites with uneven terrain for extended periods<\/p>\n<\/li>\n<li>\n<p>Ability to lift up to 50 pounds as needed<\/p>\n<\/li>\n<\/ul>\n<h3>What Turner Staffing Group Offers<\/h3>\n<ul>\n<li>\n<p>Competitive compensation based on experience<\/p>\n<\/li>\n<li>\n<p>Opportunity to work on diverse and challenging heavy civil projects<\/p>\n<\/li>\n<li>\n<p>Strong safety culture and team-oriented work environment<\/p>\n<\/li>\n<li>\n<p>Long-term career growth opportunities<\/p><\/li><\/ul>","post_title":"Field Superintendent- Heavy Civil","post_link":"https:\/\/turnerstaffing.com\/position\/field-superintendent-heavy-civil\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Senior","%location_country%":"United States","%location_city%":"Tulsa","%location_state_id%":"OK","%location_state_name%":"Oklahoma","%location_city_state%":"Tulsa, OK","%education%":"Unspecified","%department%":"","%description%":"<h2>Job Title: Field Superintendent \u2013 Heavy Civil Construction<\/h2>\n<p><strong>Location:<\/strong> Tulsa, OK (Must reside within a 40-mile radius)<br>\n<strong>Company:<\/strong> Turner Staffing Group<br>\n<strong>Work Environment:<\/strong> 100% On-Site \/ Field-Based<\/p>\n<h3>Position Overview<\/h3>\n<p>Turner Staffing Group is seeking an experienced <strong>Field Superintendent<\/strong> to oversee and manage daily field operations for heavy civil construction projects across the private, public, and municipal sectors. This role is fully on-site and requires regular travel to active job sites in and around the Tulsa area.<\/p>\n<p>The Field Superintendent will be responsible for supervising crews, coordinating subcontractors, maintaining safety and quality standards, and ensuring projects involving <strong>wet utilities, mass excavation, land clearing, and site development<\/strong> are executed safely, efficiently, and in accordance with project plans and schedules.<\/p>\n<h3>Key Responsibilities<\/h3>\n<ul>\n<li>\n<p>Manage day-to-day field operations on heavy civil construction projects<\/p>\n<\/li>\n<li>\n<p>Supervise field crews, foremen, and subcontractors to ensure productivity and quality standards are met<\/p>\n<\/li>\n<li>\n<p>Oversee construction activities related to wet utilities, mass excavation, land clearing, grading, and full site development<\/p>\n<\/li>\n<li>\n<p>Interpret and execute work per project plans, specifications, and schedules<\/p>\n<\/li>\n<li>\n<p>Coordinate manpower, equipment, and materials to maintain efficient operations<\/p>\n<\/li>\n<li>\n<p>Ensure strict compliance with safety regulations, company policies, and site-specific safety plans<\/p>\n<\/li>\n<li>\n<p>Conduct daily jobsite inspections, safety meetings, and toolbox talks<\/p>\n<\/li>\n<li>\n<p>Communicate project progress, issues, and needs to project managers and leadership<\/p>\n<\/li>\n<li>\n<p>Monitor production rates, track progress, and assist with short- and long-term planning<\/p>\n<\/li>\n<li>\n<p>Identify and resolve field issues, constructability challenges, and sequencing conflicts<\/p>\n<\/li>\n<li>\n<p>Maintain accurate daily reports, logs, and documentation<\/p>\n<\/li>\n<li>\n<p>Participate in preconstruction meetings, jobsite meetings, and inspections as required<\/p>\n<\/li>\n<\/ul>\n<h3>Required Qualifications<\/h3>\n<ul>\n<li>\n<p>Minimum <strong>7\u201310 years<\/strong> of field supervision experience in heavy civil construction<\/p>\n<\/li>\n<li>\n<p>Proven experience overseeing <strong>wet utilities, mass excavation, land clearing, and site development<\/strong> projects<\/p>\n<\/li>\n<li>\n<p>Strong knowledge of private, public, and municipal construction standards and practices<\/p>\n<\/li>\n<li>\n<p>Ability to read and interpret civil construction plans, specifications, and schedules<\/p>\n<\/li>\n<li>\n<p>Solid understanding of heavy equipment operations and earthwork production<\/p>\n<\/li>\n<li>\n<p>Strong leadership, communication, and problem-solving skills<\/p>\n<\/li>\n<li>\n<p>Commitment to safety-first construction practices<\/p>\n<\/li>\n<li>\n<p>Ability to work in a fast-paced, field-based environment<\/p>\n<\/li>\n<li>\n<p>Valid driver\u2019s license and reliable transportation<\/p>\n<\/li>\n<li>\n<p><strong>Must currently reside within a 40-mile radius of Tulsa, OK<\/strong><\/p>\n<\/li>\n<\/ul>\n<h3>Preferred Qualifications<\/h3>\n<ul>\n<li>\n<p>Experience supervising multiple crews and subcontractors simultaneously<\/p>\n<\/li>\n<li>\n<p>Familiarity with DOT, municipal, or public works projects<\/p>\n<\/li>\n<li>\n<p>OSHA 30 certification (or ability to obtain)<\/p>\n<\/li>\n<li>\n<p>Background in civil construction operations or trade experience<\/p>\n<\/li>\n<\/ul>\n<h3>Physical &amp; Work Environment Requirements<\/h3>\n<ul>\n<li>\n<p>Ability to work outdoors in varying weather conditions<\/p>\n<\/li>\n<li>\n<p>Ability to walk job sites with uneven terrain for extended periods<\/p>\n<\/li>\n<li>\n<p>Ability to lift up to 50 pounds as needed<\/p>\n<\/li>\n<\/ul>\n<h3>What Turner Staffing Group Offers<\/h3>\n<ul>\n<li>\n<p>Competitive compensation based on experience<\/p>\n<\/li>\n<li>\n<p>Opportunity to work on diverse and challenging heavy civil projects<\/p>\n<\/li>\n<li>\n<p>Strong safety culture and team-oriented work environment<\/p>\n<\/li>\n<li>\n<p>Long-term career growth opportunities<\/p><\/li><\/ul>","%category%":"Operations","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/26c9ac32a8c9-field-superintendent-heavy-civil","%breezy_id%":"26c9ac32a8c9","%breezy_friendly_id%":"26c9ac32a8c9-field-superintendent-heavy-civil","%breezy_created_date%":"2026-01-21T14:34:43.334Z","%breezy_updated_date%":"2026-01-21T14:35:14.748Z","%_wpgmp_location_city%":"Tulsa","%_wpgmp_location_state%":"OK","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Tulsa, OK, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"36.1551375","%_wpgmp_metabox_longitude%":"-95.989501","%rank_math_internal_links_processed%":"1"}},"id":3065,"infowindow_disable":false},{"source":"post","title":"Truck Shop Supervisor","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Truck Shop Supervisor\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Truck Shop Supervisor 1 Site Location Sahuarita, Arizona, United States Job Details POSITION OVERVIEW Supervise maintenance personnel and procedures to&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/truck-shop-supervisor\/\" name=\"Truck Shop Supervisor\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Truck Shop Supervisor 1 Site Location Sahuarita, Arizona, United States Job Details POSITION OVERVIEW Supervise maintenance personnel and procedures to&hellip;","address":"Sahuarita, AZ, USA","location":{"lat":"31.9575818","city":"Sahuarita","state":"AZ","country":"United States","lng":"-110.955646","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/truck-shop-supervisor\/","zoom":19,"extra_fields":{"post_excerpt":"Truck Shop Supervisor 1 Site Location Sahuarita, Arizona, United States Job Details POSITION OVERVIEW Supervise maintenance personnel and procedures to&hellip;","post_content":"<p><strong>Truck Shop Supervisor 1 <\/strong><\/p>\n<p><strong>Site Location<\/strong><\/p>\n<p>Sahuarita, Arizona, United States<\/p>\n<p><strong>Job Details<\/strong><\/p>\n<p><strong>POSITION OVERVIEW<\/strong><\/p>\n<p>Supervise maintenance personnel and procedures to provide major, routine, preventative and emergency maintenance of equipment, facilities and ensure economical and efficient operations.<\/p>\n<p><strong>Requirements<\/strong><\/p>\n<p><strong>KNOWLEDGE, SKILLS &amp; ABILITIES<\/strong><\/p>\n<ul>\n <li>Must      have above average knowledge of electrical systems, hydraulics, pneumatics      and ability to read all schematics.<\/li>\n <li>Must      have a working knowledge of diesel engines.<\/li>\n <li>The      ability to troubleshoot, perform maintenance planning, project management      and predictive management is desirable.<\/li>\n <li>Must      have good computer skills with MS Windows, MS Excel, MS Word and MS      Outlook.<\/li>\n <li>Working      knowledge of SAP a plus.<\/li>\n <li>Must      be willing to work flexible schedules, weekends and holidays.<\/li>\n <li>Must      be able to manage time effectively and set priorities.<\/li>\n <li>Requires      the ability to manage multiple tasks.<\/li>\n<\/ul>\n<p><strong>EDUCATION &amp; EXPERIENCE<\/strong><\/p>\n<ul>\n <li>Must      have a High School Diploma or GED.<\/li>\n <li>One      (1) year of college, technical school, or equivalent experience.<\/li>\n <li>Five      (5) years maintenance experience.<\/li>\n <li>One      (1) year supervisory experience.<\/li>\n<\/ul>\n<p><strong>Other Requirements:<\/strong><\/p>\n<ul>\n <li>Must      possess a valid driver\u2019s license and have a satisfactory driving record.<\/li>\n <li>Must      be able to walk over rough terrain, sit, climb ladders and stairs, squat,      kneel for extended periods of time. Work environment is outdoors and      indoors, working at extreme temperatures, weather conditions and may      be exposed to chemicals and explosives.<\/li>\n<\/ul>\n<p><strong>Pay Type<\/strong><\/p>\n<p>Salaried<\/p>","post_title":"Truck Shop Supervisor","post_link":"https:\/\/turnerstaffing.com\/position\/truck-shop-supervisor\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Senior","%location_country%":"United States","%location_city%":"Sahuarita","%location_state_id%":"AZ","%location_state_name%":"Arizona","%location_city_state%":"Sahuarita, AZ","%education%":"Unspecified","%department%":"","%description%":"<p><strong>Truck Shop Supervisor 1 <\/strong><\/p>\n<p><strong>Site Location<\/strong><\/p>\n<p>Sahuarita, Arizona, United States<\/p>\n<p><strong>Job Details<\/strong><\/p>\n<p><strong>POSITION OVERVIEW<\/strong><\/p>\n<p>Supervise maintenance personnel and procedures to provide major, routine, preventative and emergency maintenance of equipment, facilities and ensure economical and efficient operations.<\/p>\n<p><strong>Requirements<\/strong><\/p>\n<p><strong>KNOWLEDGE, SKILLS &amp; ABILITIES<\/strong><\/p>\n<ul>\n <li>Must      have above average knowledge of electrical systems, hydraulics, pneumatics      and ability to read all schematics.<\/li>\n <li>Must      have a working knowledge of diesel engines.<\/li>\n <li>The      ability to troubleshoot, perform maintenance planning, project management      and predictive management is desirable.<\/li>\n <li>Must      have good computer skills with MS Windows, MS Excel, MS Word and MS      Outlook.<\/li>\n <li>Working      knowledge of SAP a plus.<\/li>\n <li>Must      be willing to work flexible schedules, weekends and holidays.<\/li>\n <li>Must      be able to manage time effectively and set priorities.<\/li>\n <li>Requires      the ability to manage multiple tasks.<\/li>\n<\/ul>\n<p><strong>EDUCATION &amp; EXPERIENCE<\/strong><\/p>\n<ul>\n <li>Must      have a High School Diploma or GED.<\/li>\n <li>One      (1) year of college, technical school, or equivalent experience.<\/li>\n <li>Five      (5) years maintenance experience.<\/li>\n <li>One      (1) year supervisory experience.<\/li>\n<\/ul>\n<p><strong>Other Requirements:<\/strong><\/p>\n<ul>\n <li>Must      possess a valid driver\u2019s license and have a satisfactory driving record.<\/li>\n <li>Must      be able to walk over rough terrain, sit, climb ladders and stairs, squat,      kneel for extended periods of time. Work environment is outdoors and      indoors, working at extreme temperatures, weather conditions and may      be exposed to chemicals and explosives.<\/li>\n<\/ul>\n<p><strong>Pay Type<\/strong><\/p>\n<p>Salaried<\/p>","%category%":"Management","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/8f02b05994d1-truck-shop-supervisor","%breezy_id%":"8f02b05994d1","%breezy_friendly_id%":"8f02b05994d1-truck-shop-supervisor","%breezy_created_date%":"2026-01-20T19:11:45.467Z","%breezy_updated_date%":"2026-01-20T19:12:40.929Z","%_wpgmp_location_city%":"Sahuarita","%_wpgmp_location_state%":"AZ","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Sahuarita, AZ, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"31.9575818","%_wpgmp_metabox_longitude%":"-110.955646","%rank_math_internal_links_processed%":"1"}},"id":3062,"infowindow_disable":false},{"source":"post","title":"Project Engineer &#8211; Mining","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Project Engineer &#8211; Mining\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-mining\/\" name=\"Project Engineer &#8211; Mining\" 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":"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\/project-engineer-mining\/","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<ul><li>Review operational reports (cost, safety, production) and analyze data for key trends.<\/li><li>Develop and implement continuous improvement initiatives to enhance efficiency and reduce costs.<\/li><li>Conduct risk assessments for operational, technical, and financial aspects of mining projects.<\/li><li>Collaborate with engineering and operations teams to optimize mine planning, design, and extraction techniques.<\/li><li>Develop and track key performance indicators (KPIs) to monitor operational performance and drive improvements.<\/li><\/ul>\n<p><strong>Mine Engineering &amp; Survey Duties<\/strong><\/p>\n<ul><li>Manage fleet management and high precision GPS systems.<\/li><li>Develop Drill &amp; Blast pattern, profile, and timing designs and short-range plans.<\/li><li>Produce road designs, stockpile and waste storage designs, and others in Hexagon MineSight.<\/li><li>Operate survey drones and reconcile results.<\/li><li>Analyze FMS and other data for risks and opportunities.<\/li><li>Audit and advise client on short range mine plans.<\/li><\/ul>\n<p><strong>Client &amp; Cross-Functional Collaboration<\/strong><\/p>\n<ul><li>Work closely with Turner Mining departments and external stakeholders to define project scopes and execution strategies.<\/li><li>Act as a technical link between client technical services and project management to ensure alignment on operational objectives.<\/li><li>Participate in knowledge-sharing initiatives, such as internal workshops and training, to support operational and analytical capabilities across teams.<\/li><li>Engage with suppliers and service providers to optimize procurement strategies for project operations.<\/li><\/ul>\n<p><strong>Compliance and Safety Integration<\/strong><\/p>\n<ul><li>Ensure that all engineering recommendations align with MSHA safety regulations and industry best practices.<\/li><li>Develop and maintain standard operating procedures (SOPs) for operational and safety processes.<\/li><li>Provide technical guidance to ensure site compliance with environmental and regulatory requirements.<\/li><\/ul>\n<ul><li>Other duties as required.<\/li><\/ul>\n<p><strong>The Ideal Candidate:<\/strong><\/p>\n<p><strong>Education and Experience<\/strong><\/p>\n<ul><li>Mining or Civil Engineering Degree or related.<\/li><li>3 years of mine site engineering or operational experience.<\/li><li>Hands-on experience with mining engineering software (Hexagon MineSight preferred or similar).<\/li><li>Strong proficiency in MS Office (Word, Excel, PowerPoint, Outlook).<\/li><li>Part 107 drone license preferred<\/li><li>Procurement and mine accounting experience preferred<\/li><\/ul>\n<p><strong>Technical and Analytical Skills<\/strong><\/p>\n<ul><li>Strong problem-solving and data analysis capabilities.<\/li><li>Ability to translate complex engineering data into actionable recommendations.<\/li><li>Knowledge of drill &amp; blast design, mine haulage analysis, and GPS fleet management.<\/li><li>Familiarity with mine accounting and procurement processes (preferred but not required).<\/li><\/ul>\n<p><strong>Key Competencies \/ Skills<\/strong><\/p>\n<ul><li>Results-oriented with a proactive, problem-solving mindset.<\/li><li>Effective communicator, capable of working with cross-functional teams and clients.<\/li><li>Ability to work independently and manage multiple priorities in a dynamic environment.<\/li><li>Detail-oriented with strong documentation and technical writing skills.<\/li><\/ul>\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. 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":"Project Engineer &#8211; Mining","post_link":"https:\/\/turnerstaffing.com\/position\/project-engineer-mining\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Mid Level","%location_country%":"United States","%location_city%":"Ely","%location_state_id%":"NV","%location_state_name%":"Nevada","%location_city_state%":"Ely, NV","%education%":"Bachelor's Degree","%department%":"","%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<ul><li>Review operational reports (cost, safety, production) and analyze data for key trends.<\/li><li>Develop and implement continuous improvement initiatives to enhance efficiency and reduce costs.<\/li><li>Conduct risk assessments for operational, technical, and financial aspects of mining projects.<\/li><li>Collaborate with engineering and operations teams to optimize mine planning, design, and extraction techniques.<\/li><li>Develop and track key performance indicators (KPIs) to monitor operational performance and drive improvements.<\/li><\/ul>\n<p><strong>Mine Engineering &amp; Survey Duties<\/strong><\/p>\n<ul><li>Manage fleet management and high precision GPS systems.<\/li><li>Develop Drill &amp; Blast pattern, profile, and timing designs and short-range plans.<\/li><li>Produce road designs, stockpile and waste storage designs, and others in Hexagon MineSight.<\/li><li>Operate survey drones and reconcile results.<\/li><li>Analyze FMS and other data for risks and opportunities.<\/li><li>Audit and advise client on short range mine plans.<\/li><\/ul>\n<p><strong>Client &amp; Cross-Functional Collaboration<\/strong><\/p>\n<ul><li>Work closely with Turner Mining departments and external stakeholders to define project scopes and execution strategies.<\/li><li>Act as a technical link between client technical services and project management to ensure alignment on operational objectives.<\/li><li>Participate in knowledge-sharing initiatives, such as internal workshops and training, to support operational and analytical capabilities across teams.<\/li><li>Engage with suppliers and service providers to optimize procurement strategies for project operations.<\/li><\/ul>\n<p><strong>Compliance and Safety Integration<\/strong><\/p>\n<ul><li>Ensure that all engineering recommendations align with MSHA safety regulations and industry best practices.<\/li><li>Develop and maintain standard operating procedures (SOPs) for operational and safety processes.<\/li><li>Provide technical guidance to ensure site compliance with environmental and regulatory requirements.<\/li><\/ul>\n<ul><li>Other duties as required.<\/li><\/ul>\n<p><strong>The Ideal Candidate:<\/strong><\/p>\n<p><strong>Education and Experience<\/strong><\/p>\n<ul><li>Mining or Civil Engineering Degree or related.<\/li><li>3 years of mine site engineering or operational experience.<\/li><li>Hands-on experience with mining engineering software (Hexagon MineSight preferred or similar).<\/li><li>Strong proficiency in MS Office (Word, Excel, PowerPoint, Outlook).<\/li><li>Part 107 drone license preferred<\/li><li>Procurement and mine accounting experience preferred<\/li><\/ul>\n<p><strong>Technical and Analytical Skills<\/strong><\/p>\n<ul><li>Strong problem-solving and data analysis capabilities.<\/li><li>Ability to translate complex engineering data into actionable recommendations.<\/li><li>Knowledge of drill &amp; blast design, mine haulage analysis, and GPS fleet management.<\/li><li>Familiarity with mine accounting and procurement processes (preferred but not required).<\/li><\/ul>\n<p><strong>Key Competencies \/ Skills<\/strong><\/p>\n<ul><li>Results-oriented with a proactive, problem-solving mindset.<\/li><li>Effective communicator, capable of working with cross-functional teams and clients.<\/li><li>Ability to work independently and manage multiple priorities in a dynamic environment.<\/li><li>Detail-oriented with strong documentation and technical writing skills.<\/li><\/ul>\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. 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\/7f3758844762-project-engineer-mining","%breezy_id%":"7f3758844762","%breezy_friendly_id%":"7f3758844762-project-engineer-mining","%breezy_created_date%":"2026-01-20T17:06:09.805Z","%breezy_updated_date%":"2026-01-20T17:07:26.122Z","%_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":3058,"infowindow_disable":false},{"source":"post","title":"Business Technologies Engineer I","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Business Technologies Engineer I\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Business Technologies Engineer 1 Site Location Kearny, Arizona, United States Job Details REQUIRED KNOWLEDGE SKILLS AND ABILITIES Strong understanding of&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/business-technologies-engineer-i\/\" name=\"Business Technologies Engineer I\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Business Technologies Engineer 1 Site Location Kearny, Arizona, United States Job Details REQUIRED KNOWLEDGE SKILLS AND ABILITIES Strong understanding of&hellip;","address":"Kearny, AZ, USA","location":{"lat":"33.0613504","city":"Kearny","state":"AZ","country":"United States","lng":"-110.9066589","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/business-technologies-engineer-i\/","zoom":19,"extra_fields":{"post_excerpt":"Business Technologies Engineer 1 Site Location Kearny, Arizona, United States Job Details REQUIRED KNOWLEDGE SKILLS AND ABILITIES Strong understanding of&hellip;","post_content":"<p><strong>Business Technologies Engineer 1 <\/strong><\/p>\n<p><strong>Site Location<\/strong><\/p>\n<p>Kearny, Arizona, United States<\/p>\n<p><strong>Job Details<\/strong><\/p>\n<p><strong>REQUIRED KNOWLEDGE SKILLS AND ABILITIES<\/strong><\/p>\n<ul>\n <li>Strong      understanding of technical processes and how they can address the process      business needs<\/li>\n <li>Desire      to work with multi-functional teams in a multi-national organization<\/li>\n <li>Highly      Motivated, Proactive Self-starter, with a passion for technology solutions      in the process environment.<\/li>\n <li>Ability      to work both independently and as a part of a team in a fast-paced      production focused environment<\/li>\n <li>Ability      to identify opportunities in new technologies, trends, and changes in the      information management and research field<\/li>\n <li>Excellent      communication skills (the ability to listen to, explain to and influence      Stakeholders) and the ability to partner with critical business \/      infrastructure and ability to clearly formulate positions on issues and      articulate solutions<\/li>\n <li>Able      to perform analytical assessment of datasets and information flows across      an extensive range of process business types and systems<\/li>\n <li>Methodical      with an analytical approach, paying close attention to detail<\/li>\n <li>Highly      organized and efficient with the ability to work well under pressure and      meet challenging deadlines.<\/li>\n <li>Ability      to manage time effectively and set priorities.<\/li>\n <li>Ability      to think under stressful and adverse conditions<\/li>\n<\/ul>\n<p><strong>Requirements<\/strong><\/p>\n<p><strong>REQUIRED EDUCATION AND EXPERIENCE<\/strong><\/p>\n<ul>\n <li>Experience      in technical\/operational tasks and roles.<\/li>\n<\/ul>\n<p>English language fluency<\/p>\n<p><strong>Pay Type<\/strong><\/p>\n<p>Salaried<\/p>","post_title":"Business Technologies Engineer I","post_link":"https:\/\/turnerstaffing.com\/position\/business-technologies-engineer-i\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Associate","%location_country%":"United States","%location_city%":"Kearny","%location_state_id%":"AZ","%location_state_name%":"Arizona","%location_city_state%":"Kearny, AZ","%education%":"Unspecified","%department%":"Engineering","%description%":"<p><strong>Business Technologies Engineer 1 <\/strong><\/p>\n<p><strong>Site Location<\/strong><\/p>\n<p>Kearny, Arizona, United States<\/p>\n<p><strong>Job Details<\/strong><\/p>\n<p><strong>REQUIRED KNOWLEDGE SKILLS AND ABILITIES<\/strong><\/p>\n<ul>\n <li>Strong      understanding of technical processes and how they can address the process      business needs<\/li>\n <li>Desire      to work with multi-functional teams in a multi-national organization<\/li>\n <li>Highly      Motivated, Proactive Self-starter, with a passion for technology solutions      in the process environment.<\/li>\n <li>Ability      to work both independently and as a part of a team in a fast-paced      production focused environment<\/li>\n <li>Ability      to identify opportunities in new technologies, trends, and changes in the      information management and research field<\/li>\n <li>Excellent      communication skills (the ability to listen to, explain to and influence      Stakeholders) and the ability to partner with critical business \/      infrastructure and ability to clearly formulate positions on issues and      articulate solutions<\/li>\n <li>Able      to perform analytical assessment of datasets and information flows across      an extensive range of process business types and systems<\/li>\n <li>Methodical      with an analytical approach, paying close attention to detail<\/li>\n <li>Highly      organized and efficient with the ability to work well under pressure and      meet challenging deadlines.<\/li>\n <li>Ability      to manage time effectively and set priorities.<\/li>\n <li>Ability      to think under stressful and adverse conditions<\/li>\n<\/ul>\n<p><strong>Requirements<\/strong><\/p>\n<p><strong>REQUIRED EDUCATION AND EXPERIENCE<\/strong><\/p>\n<ul>\n <li>Experience      in technical\/operational tasks and roles.<\/li>\n<\/ul>\n<p>English language fluency<\/p>\n<p><strong>Pay Type<\/strong><\/p>\n<p>Salaried<\/p>","%category%":"Other","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/a5712d7d963a-business-technologies-engineer-i","%breezy_id%":"a5712d7d963a","%breezy_friendly_id%":"a5712d7d963a-business-technologies-engineer-i","%breezy_created_date%":"2026-01-20T18:59:45.799Z","%breezy_updated_date%":"2026-01-20T19:00:52.768Z","%_wpgmp_location_city%":"Kearny","%_wpgmp_location_state%":"AZ","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Kearny, AZ, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"33.0613504","%_wpgmp_metabox_longitude%":"-110.9066589","%rank_math_internal_links_processed%":"1"}},"id":3059,"infowindow_disable":false},{"source":"post","title":"Field Systems Engineer","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Field Systems Engineer\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Field Systems Engineer Site Location Sahuarita, Arizona, United States Job Details Position Overview The Engineer \u2013 Field Systems is responsible&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/field-systems-engineer\/\" name=\"Field Systems Engineer\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Field Systems Engineer Site Location Sahuarita, Arizona, United States Job Details Position Overview The Engineer \u2013 Field Systems is responsible&hellip;","address":"Sahuarita, AZ, USA","location":{"lat":"31.9575818","city":"Sahuarita","state":"AZ","country":"United States","lng":"-110.955646","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/field-systems-engineer\/","zoom":19,"extra_fields":{"post_excerpt":"Field Systems Engineer Site Location Sahuarita, Arizona, United States Job Details Position Overview The Engineer \u2013 Field Systems is responsible&hellip;","post_content":"<p><strong>Field Systems Engineer<\/strong><\/p>\n<p><strong>Site Location<\/strong><\/p>\n<p>Sahuarita, Arizona, United States<\/p>\n<p><strong>Job Details<\/strong><\/p>\n<p><strong>Position Overview<\/strong><\/p>\n<p>The Engineer \u2013 Field Systems is responsible for supporting, maintaining, and continuously improving all mine technologies at the Mission Mine site. This includes fleet management (DISPATCH\u00ae), communications networks, cameras, radio systems, shovel and drill monitoring systems, and other digital safety and productivity technologies.<\/p>\n<p>The Engineer will serve as the primary technical resource for field-level systems, ensuring equipment reliability, connectivity in the pit, and integration across mine operations. This role combines hands-on technical work with the ability to coordinate with technicians, vendors, and mine operations staff to keep mission-critical technologies running smoothly.<\/p>\n<p><strong>Essential Functions<\/strong><\/p>\n<ul>\n <li>Mine      Technology Support<\/li>\n <li>Provide      installation, configuration, troubleshooting, and maintenance of all mine      technology systems at Mission, including but not limited to:<\/li>\n <li>Fleet      Management Systems<\/li>\n <li>DISPATCH\u00ae      Fleet Management System (FMS)<\/li>\n <li>Modular      Provision (Ore &amp; Grade Control)<\/li>\n <li>Equipment      Monitoring<\/li>\n <li>Epiroc      shovel and drill metrics systems<\/li>\n <li>Payload      Management Systems (PLM)<\/li>\n <li>Caterpillar      Minestar Terrain \/ AccuGrade guidance systems<\/li>\n <li>Safety      &amp; Operator Technologies<\/li>\n <li>Operator      Awareness \/ Fatigue Management Systems (Hexagon OAS)<\/li>\n <li>Orica      BlastIQ \/ Fragtrac<\/li>\n <li>Split      Engineering fragmentation monitoring<\/li>\n <li>Slope      stability monitoring (GroundProbe, GeoExplorer)<\/li>\n <li>Michelin      MEMS tire management system<\/li>\n <li>Communications      &amp; Network Systems<\/li>\n <li>Two-way      radios (voice &amp; data)<\/li>\n <li>Pit      wireless networks (LAN\/WLAN, Wi-Fi, mesh, microwave links)<\/li>\n <li>Video      monitoring and security camera systems<\/li>\n <li>Trimble      base station corrections<\/li>\n<\/ul>\n<p><strong>Field Operations &amp; Reliability<\/strong><\/p>\n<ul>\n <li>Respond      to system issues as part of an on-call rotation, performing both remote      troubleshooting and in-pit fieldwork to restore functionality.<\/li>\n <li>Coordinate      with Mine Operations, Maintenance, and Engineering to ensure technology      supports production goals.<\/li>\n <li>Work      with vendors (e.g., Modular, Epiroc) to manage repairs, RMAs, and ongoing      technical support agreements.<\/li>\n <li>Maintain      adequate spare parts and replacement components to minimize downtime.<\/li>\n<\/ul>\n<p><strong>Continuous Improvement<\/strong><\/p>\n<ul>\n <li>Collaborate      with management and technology teams to identify opportunities to optimize      system performance.<\/li>\n <li>Support      adoption of new technologies and upgrades that enhance safety,      productivity, or communication.<\/li>\n <li>Participate      in cross-site collaboration with other teams to share best practices and      improvements.<\/li>\n<\/ul>\n<p><strong>Safety &amp; Compliance<\/strong><\/p>\n<ul>\n <li>Coordinate      with the Mission Safety Department on safety-related system support.<\/li>\n <li>Maintain      compliance with MSHA and environmental regulations.<\/li>\n<\/ul>\n<p><strong>Required Knowledge, Skills &amp; Abilities<\/strong><\/p>\n<ul>\n <li>Strong      working knowledge of mine technology systems including Dispatch, Epiroc      shovel\/drill metrics, radios, pit networks, cameras, and safety systems.<\/li>\n <li>Experience      supporting network infrastructure in pit operations (wireless, mesh,      radio, microwave).<\/li>\n <li>Strong      hardware and system troubleshooting ability.<\/li>\n <li>Effective      communication skills, able to work with both technical staff and mine      operators.<\/li>\n <li>Ability      to perform fieldwork in challenging mine environments (heat, dust, uneven      terrain).<\/li>\n <li>Must      be able to lift objects over 50 lbs.<\/li>\n <li>Valid      driver\u2019s license required.<\/li>\n<\/ul>\n<p><strong>Requirements<\/strong><\/p>\n<p><strong>Education &amp; Experience<\/strong><\/p>\n<ul>\n <li>Bachelor\u2019s      degree in Engineering, Electronics, or related technical field preferred;      or equivalent experience.<\/li>\n <li>3\u20136      years of experience supporting mine technology systems (Dispatch, radio,      networks, shovel\/drill systems, or similar).<\/li>\n <li>Experience      in open-pit mining operations strongly preferred.<\/li>\n<\/ul>\n<p><strong>Pay Type<\/strong><\/p>\n<p>Salaried<\/p>","post_title":"Field Systems Engineer","post_link":"https:\/\/turnerstaffing.com\/position\/field-systems-engineer\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Mid Level","%location_country%":"United States","%location_city%":"Sahuarita","%location_state_id%":"AZ","%location_state_name%":"Arizona","%location_city_state%":"Sahuarita, AZ","%education%":"Bachelor's Degree","%department%":"Engineering","%description%":"<p><strong>Field Systems Engineer<\/strong><\/p>\n<p><strong>Site Location<\/strong><\/p>\n<p>Sahuarita, Arizona, United States<\/p>\n<p><strong>Job Details<\/strong><\/p>\n<p><strong>Position Overview<\/strong><\/p>\n<p>The Engineer \u2013 Field Systems is responsible for supporting, maintaining, and continuously improving all mine technologies at the Mission Mine site. This includes fleet management (DISPATCH\u00ae), communications networks, cameras, radio systems, shovel and drill monitoring systems, and other digital safety and productivity technologies.<\/p>\n<p>The Engineer will serve as the primary technical resource for field-level systems, ensuring equipment reliability, connectivity in the pit, and integration across mine operations. This role combines hands-on technical work with the ability to coordinate with technicians, vendors, and mine operations staff to keep mission-critical technologies running smoothly.<\/p>\n<p><strong>Essential Functions<\/strong><\/p>\n<ul>\n <li>Mine      Technology Support<\/li>\n <li>Provide      installation, configuration, troubleshooting, and maintenance of all mine      technology systems at Mission, including but not limited to:<\/li>\n <li>Fleet      Management Systems<\/li>\n <li>DISPATCH\u00ae      Fleet Management System (FMS)<\/li>\n <li>Modular      Provision (Ore &amp; Grade Control)<\/li>\n <li>Equipment      Monitoring<\/li>\n <li>Epiroc      shovel and drill metrics systems<\/li>\n <li>Payload      Management Systems (PLM)<\/li>\n <li>Caterpillar      Minestar Terrain \/ AccuGrade guidance systems<\/li>\n <li>Safety      &amp; Operator Technologies<\/li>\n <li>Operator      Awareness \/ Fatigue Management Systems (Hexagon OAS)<\/li>\n <li>Orica      BlastIQ \/ Fragtrac<\/li>\n <li>Split      Engineering fragmentation monitoring<\/li>\n <li>Slope      stability monitoring (GroundProbe, GeoExplorer)<\/li>\n <li>Michelin      MEMS tire management system<\/li>\n <li>Communications      &amp; Network Systems<\/li>\n <li>Two-way      radios (voice &amp; data)<\/li>\n <li>Pit      wireless networks (LAN\/WLAN, Wi-Fi, mesh, microwave links)<\/li>\n <li>Video      monitoring and security camera systems<\/li>\n <li>Trimble      base station corrections<\/li>\n<\/ul>\n<p><strong>Field Operations &amp; Reliability<\/strong><\/p>\n<ul>\n <li>Respond      to system issues as part of an on-call rotation, performing both remote      troubleshooting and in-pit fieldwork to restore functionality.<\/li>\n <li>Coordinate      with Mine Operations, Maintenance, and Engineering to ensure technology      supports production goals.<\/li>\n <li>Work      with vendors (e.g., Modular, Epiroc) to manage repairs, RMAs, and ongoing      technical support agreements.<\/li>\n <li>Maintain      adequate spare parts and replacement components to minimize downtime.<\/li>\n<\/ul>\n<p><strong>Continuous Improvement<\/strong><\/p>\n<ul>\n <li>Collaborate      with management and technology teams to identify opportunities to optimize      system performance.<\/li>\n <li>Support      adoption of new technologies and upgrades that enhance safety,      productivity, or communication.<\/li>\n <li>Participate      in cross-site collaboration with other teams to share best practices and      improvements.<\/li>\n<\/ul>\n<p><strong>Safety &amp; Compliance<\/strong><\/p>\n<ul>\n <li>Coordinate      with the Mission Safety Department on safety-related system support.<\/li>\n <li>Maintain      compliance with MSHA and environmental regulations.<\/li>\n<\/ul>\n<p><strong>Required Knowledge, Skills &amp; Abilities<\/strong><\/p>\n<ul>\n <li>Strong      working knowledge of mine technology systems including Dispatch, Epiroc      shovel\/drill metrics, radios, pit networks, cameras, and safety systems.<\/li>\n <li>Experience      supporting network infrastructure in pit operations (wireless, mesh,      radio, microwave).<\/li>\n <li>Strong      hardware and system troubleshooting ability.<\/li>\n <li>Effective      communication skills, able to work with both technical staff and mine      operators.<\/li>\n <li>Ability      to perform fieldwork in challenging mine environments (heat, dust, uneven      terrain).<\/li>\n <li>Must      be able to lift objects over 50 lbs.<\/li>\n <li>Valid      driver\u2019s license required.<\/li>\n<\/ul>\n<p><strong>Requirements<\/strong><\/p>\n<p><strong>Education &amp; Experience<\/strong><\/p>\n<ul>\n <li>Bachelor\u2019s      degree in Engineering, Electronics, or related technical field preferred;      or equivalent experience.<\/li>\n <li>3\u20136      years of experience supporting mine technology systems (Dispatch, radio,      networks, shovel\/drill systems, or similar).<\/li>\n <li>Experience      in open-pit mining operations strongly preferred.<\/li>\n<\/ul>\n<p><strong>Pay Type<\/strong><\/p>\n<p>Salaried<\/p>","%category%":"Other","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/ba489f10c5e5-field-systems-engineer","%breezy_id%":"ba489f10c5e5","%breezy_friendly_id%":"ba489f10c5e5-field-systems-engineer","%breezy_created_date%":"2026-01-20T19:02:36.713Z","%breezy_updated_date%":"2026-01-20T19:03:23.321Z","%_wpgmp_location_city%":"Sahuarita","%_wpgmp_location_state%":"AZ","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Sahuarita, AZ, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"31.9575818","%_wpgmp_metabox_longitude%":"-110.955646","%rank_math_internal_links_processed%":"1"}},"id":3060,"infowindow_disable":false},{"source":"post","title":"Electrical Supervisor","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Electrical Supervisor\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Electrical Supervisor 1 Site Location Sahuarita, Arizona, United States Job Details POSITION OVERVIEW Plan, direct, and supervise the work of&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/electrical-supervisor\/\" name=\"Electrical Supervisor\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Electrical Supervisor 1 Site Location Sahuarita, Arizona, United States Job Details POSITION OVERVIEW Plan, direct, and supervise the work of&hellip;","address":"Sahuarita, AZ, USA","location":{"lat":"31.9575818","city":"Sahuarita","state":"AZ","country":"United States","lng":"-110.955646","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/electrical-supervisor\/","zoom":19,"extra_fields":{"post_excerpt":"Electrical Supervisor 1 Site Location Sahuarita, Arizona, United States Job Details POSITION OVERVIEW Plan, direct, and supervise the work of&hellip;","post_content":"<p><strong>Electrical Supervisor 1<\/strong><\/p>\n<p><strong>Site Location<\/strong><\/p>\n<p>Sahuarita, Arizona, United States<\/p>\n<p><strong>Job Details<\/strong><\/p>\n<p><strong>POSITION OVERVIEW<\/strong><\/p>\n<p>Plan, direct, and supervise the work of the Electrical and Instrumentation Maintenance staff in maintaining a wide variety of electrical, controls, motors and instrumentation equipment throughout the Mining and Milling operations and support facilities. Effectively maintain the plant electrical systems to consistently support budgeted production goals and operations.<\/p>\n<p><strong>ESSENTIAL FUNCTIONS<\/strong><\/p>\n<ul>\n <li>Provide      direction and supervision of department maintenance personnel; inspect and      review the work of subordinates.<\/li>\n <li>Develop,      prioritize, and implement both scheduled and unplanned maintenance      activities.<\/li>\n <li>Coordinate      and emphasize a preventive maintenance program; including order supplies      and necessary materials.<\/li>\n <li>Monitor      and ensure safe work practices and safety compliance within department      personnel; develop safe work practices and procedures; emphasize and      promote an attitude of safe and proper work practices within the      department.<\/li>\n <li>Communicate      with production and other maintenance department supervision daily to      effectively prioritize tasks and provide feedback on work requirements and      progress.<\/li>\n <li>Provide      technical skills and knowledge to assist in timely and competent      troubleshooting and repairs to equipment.<\/li>\n <li>Instruct      and oversee training and development of junior level electricians to      journey level.<\/li>\n <li>Perform      safety and environmental inspections and maintain records as required for      regulating agencies and company policies.<\/li>\n <li>Coordinate      and oversee new installation and project work; including developing and      ordering necessary supplies, materials, and equipment.<\/li>\n <li>Assist      in monitoring and controlling department budget costs, electrical repairs,      and maintenance costs within the operating budgets.<\/li>\n <li>Coordinate      and oversee onsite contractors in performance of maintenance work and      projects.<\/li>\n <li>Responsible      for executing, supporting, and enforcing the Company's Environmental,      Health and Safety program as required by OIS policy, directives, and      principles.<\/li>\n<\/ul>\n<p><strong>Requirements<\/strong><\/p>\n<p><strong>KNOWLEDGE SKILLS AND ABILITIES<\/strong><\/p>\n<ul>\n <li>Ability      to effectively supervise and direct journey level electricians and      instrument technicians in a unionized environment.<\/li>\n <li>Knowledge      of safe electrical work practices and procedures.<\/li>\n <li>Ability      to operate electrical and electronic test equipment.<\/li>\n <li>Capability      to logically diagnose electrical problems and perform troubleshooting with      sound, effective methodology.<\/li>\n <li>Ability      to diagnose problems and troubleshoot PLC based electrical controls.<\/li>\n <li>Knowledge      of electrical protective relaying applications and maintenance.<\/li>\n <li>Ability      to provide effective oral and written communications.<\/li>\n <li>Basic      computer skills and knowledge of MS Windows, MS Word, MS Outlook, and MS      Excel.<\/li>\n<\/ul>\n<p><strong>EDUCATION AND EXPERIENCE<\/strong><\/p>\n<ul>\n <li>Three years\u2019      experience as a front-line electrical supervisor within the mining      industry or other heavy industry.<\/li>\n <li>Demonstrated      performance and experience as a journey level electrician in the mining      industry or other heavy industry.<\/li>\n <li>Experienced      with safely operating and maintaining power distribution circuits and      equipment through 13.8kV and medium voltage motor control.<\/li>\n <li>Formal      training and first-hand experience in programming and maintenance of      industrial PLC\u2019s, preferably Allen-Bradley.<\/li>\n <li>Associate      Degree from an accredited college or vocational\/technical school in      an electrical technical field is desirable, but not required.<\/li>\n <li>English      language fluency:<\/li>\n <ul>\n  <li>At       least CEFR B2 - Upper Intermediate: Can understand the main ideas of       complex text on both concrete and abstract topics, including technical       discussions in their field of specialization.<\/li>\n <\/ul>\n<\/ul>\n<p>  <\/p>\n<p><strong>Pay Type<\/strong><\/p>\n<p>Salaried<\/p>","post_title":"Electrical Supervisor","post_link":"https:\/\/turnerstaffing.com\/position\/electrical-supervisor\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Senior","%location_country%":"United States","%location_city%":"Sahuarita","%location_state_id%":"AZ","%location_state_name%":"Arizona","%location_city_state%":"Sahuarita, AZ","%education%":"","%department%":"","%description%":"<p><strong>Electrical Supervisor 1<\/strong><\/p>\n<p><strong>Site Location<\/strong><\/p>\n<p>Sahuarita, Arizona, United States<\/p>\n<p><strong>Job Details<\/strong><\/p>\n<p><strong>POSITION OVERVIEW<\/strong><\/p>\n<p>Plan, direct, and supervise the work of the Electrical and Instrumentation Maintenance staff in maintaining a wide variety of electrical, controls, motors and instrumentation equipment throughout the Mining and Milling operations and support facilities. Effectively maintain the plant electrical systems to consistently support budgeted production goals and operations.<\/p>\n<p><strong>ESSENTIAL FUNCTIONS<\/strong><\/p>\n<ul>\n <li>Provide      direction and supervision of department maintenance personnel; inspect and      review the work of subordinates.<\/li>\n <li>Develop,      prioritize, and implement both scheduled and unplanned maintenance      activities.<\/li>\n <li>Coordinate      and emphasize a preventive maintenance program; including order supplies      and necessary materials.<\/li>\n <li>Monitor      and ensure safe work practices and safety compliance within department      personnel; develop safe work practices and procedures; emphasize and      promote an attitude of safe and proper work practices within the      department.<\/li>\n <li>Communicate      with production and other maintenance department supervision daily to      effectively prioritize tasks and provide feedback on work requirements and      progress.<\/li>\n <li>Provide      technical skills and knowledge to assist in timely and competent      troubleshooting and repairs to equipment.<\/li>\n <li>Instruct      and oversee training and development of junior level electricians to      journey level.<\/li>\n <li>Perform      safety and environmental inspections and maintain records as required for      regulating agencies and company policies.<\/li>\n <li>Coordinate      and oversee new installation and project work; including developing and      ordering necessary supplies, materials, and equipment.<\/li>\n <li>Assist      in monitoring and controlling department budget costs, electrical repairs,      and maintenance costs within the operating budgets.<\/li>\n <li>Coordinate      and oversee onsite contractors in performance of maintenance work and      projects.<\/li>\n <li>Responsible      for executing, supporting, and enforcing the Company's Environmental,      Health and Safety program as required by OIS policy, directives, and      principles.<\/li>\n<\/ul>\n<p><strong>Requirements<\/strong><\/p>\n<p><strong>KNOWLEDGE SKILLS AND ABILITIES<\/strong><\/p>\n<ul>\n <li>Ability      to effectively supervise and direct journey level electricians and      instrument technicians in a unionized environment.<\/li>\n <li>Knowledge      of safe electrical work practices and procedures.<\/li>\n <li>Ability      to operate electrical and electronic test equipment.<\/li>\n <li>Capability      to logically diagnose electrical problems and perform troubleshooting with      sound, effective methodology.<\/li>\n <li>Ability      to diagnose problems and troubleshoot PLC based electrical controls.<\/li>\n <li>Knowledge      of electrical protective relaying applications and maintenance.<\/li>\n <li>Ability      to provide effective oral and written communications.<\/li>\n <li>Basic      computer skills and knowledge of MS Windows, MS Word, MS Outlook, and MS      Excel.<\/li>\n<\/ul>\n<p><strong>EDUCATION AND EXPERIENCE<\/strong><\/p>\n<ul>\n <li>Three years\u2019      experience as a front-line electrical supervisor within the mining      industry or other heavy industry.<\/li>\n <li>Demonstrated      performance and experience as a journey level electrician in the mining      industry or other heavy industry.<\/li>\n <li>Experienced      with safely operating and maintaining power distribution circuits and      equipment through 13.8kV and medium voltage motor control.<\/li>\n <li>Formal      training and first-hand experience in programming and maintenance of      industrial PLC\u2019s, preferably Allen-Bradley.<\/li>\n <li>Associate      Degree from an accredited college or vocational\/technical school in      an electrical technical field is desirable, but not required.<\/li>\n <li>English      language fluency:<\/li>\n <ul>\n  <li>At       least CEFR B2 - Upper Intermediate: Can understand the main ideas of       complex text on both concrete and abstract topics, including technical       discussions in their field of specialization.<\/li>\n <\/ul>\n<\/ul>\n<p>  <\/p>\n<p><strong>Pay Type<\/strong><\/p>\n<p>Salaried<\/p>","%category%":"Other","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/e9c68e61afa5-electrical-supervisor","%breezy_id%":"e9c68e61afa5","%breezy_friendly_id%":"e9c68e61afa5-electrical-supervisor","%breezy_created_date%":"2026-01-20T19:05:12.336Z","%breezy_updated_date%":"2026-01-20T19:06:12.643Z","%_wpgmp_location_city%":"Sahuarita","%_wpgmp_location_state%":"AZ","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Sahuarita, AZ, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"31.9575818","%_wpgmp_metabox_longitude%":"-110.955646","%rank_math_internal_links_processed%":"1"}},"id":3061,"infowindow_disable":false},{"source":"post","title":"General Manager","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    General Manager\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Our client is seeking an experienced General Manager to lead and optimize all operations for their Rialto, CA&nbsp;facility. This role&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/general-manager\/\" name=\"General Manager\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Our client is seeking an experienced General Manager to lead and optimize all operations for their Rialto, CA&nbsp;facility. This role&hellip;","address":"Rialto, CA, USA","location":{"lat":"34.1064001","city":"Rialto","state":"CA","country":"United States","lng":"-117.3703235","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/general-manager\/","zoom":19,"extra_fields":{"post_excerpt":"Our client is seeking an experienced General Manager to lead and optimize all operations for their Rialto, CA&nbsp;facility. This role&hellip;","post_content":"<p>Our client is seeking an experienced General Manager to lead and optimize all operations for their Rialto, CA&nbsp;facility. This role is responsible for driving operational performance, improving productivity, ensuring safety and quality, and supporting long-term growth objectives.<\/p>\n<h2><strong>Key Responsibilities<\/strong><\/h2>\n<ul>\n<li>Lead all operations, including manufacturing, distribution, maintenance, quality, and safety.<\/li>\n<li>Develop and execute strategies, policies, and processes to improve efficiency and support business goals.<\/li>\n<li>Establish and monitor metrics, productivity targets, and performance reporting.<\/li>\n<li>Manage budgets, analyze financial data, and drive cost efficiency.<\/li>\n<li>Build, develop, and mentor operational teams; ensure strong accountability and performance.<\/li>\n<li>Drive a culture of safety, quality, and continuous improvement.<\/li>\n<li>Identify growth opportunities and support organizational objectives.<\/li>\n<li>Partner with internal teams such as EHS, HR, Logistics, and Maintenance.<\/li>\n<\/ul>\n<h2><strong>Qualifications<\/strong><\/h2>\n<ul>\n<li>Bachelor\u2019s degree required.<\/li>\n<li>8+ years of operations management experience in manufacturing (construction-related preferred).<\/li>\n<li>Proven success leading large teams and collaborating with executive leadership.<\/li>\n<li>Strong experience managing budgets, P&amp;L, and data-driven decision-making.<\/li>\n<li>Excellent communication, leadership, and organizational skills.<\/li>\n<li>Proficient with MS Office, MS Project, Visio, or similar tools.<\/li><\/ul><p>The role is based in Rialto,&nbsp;CA location.&nbsp;<\/p>","post_title":"General Manager","post_link":"https:\/\/turnerstaffing.com\/position\/general-manager\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"","%location_country%":"United States","%location_city%":"Rialto","%location_state_id%":"CA","%location_state_name%":"California","%location_city_state%":"Rialto, CA","%education%":"Bachelor's Degree","%department%":"","%description%":"<p>Our client is seeking an experienced General Manager to lead and optimize all operations for their Rialto, CA&nbsp;facility. This role is responsible for driving operational performance, improving productivity, ensuring safety and quality, and supporting long-term growth objectives.<\/p>\n<h2><strong>Key Responsibilities<\/strong><\/h2>\n<ul>\n<li>Lead all operations, including manufacturing, distribution, maintenance, quality, and safety.<\/li>\n<li>Develop and execute strategies, policies, and processes to improve efficiency and support business goals.<\/li>\n<li>Establish and monitor metrics, productivity targets, and performance reporting.<\/li>\n<li>Manage budgets, analyze financial data, and drive cost efficiency.<\/li>\n<li>Build, develop, and mentor operational teams; ensure strong accountability and performance.<\/li>\n<li>Drive a culture of safety, quality, and continuous improvement.<\/li>\n<li>Identify growth opportunities and support organizational objectives.<\/li>\n<li>Partner with internal teams such as EHS, HR, Logistics, and Maintenance.<\/li>\n<\/ul>\n<h2><strong>Qualifications<\/strong><\/h2>\n<ul>\n<li>Bachelor\u2019s degree required.<\/li>\n<li>8+ years of operations management experience in manufacturing (construction-related preferred).<\/li>\n<li>Proven success leading large teams and collaborating with executive leadership.<\/li>\n<li>Strong experience managing budgets, P&amp;L, and data-driven decision-making.<\/li>\n<li>Excellent communication, leadership, and organizational skills.<\/li>\n<li>Proficient with MS Office, MS Project, Visio, or similar tools.<\/li><\/ul><p>The role is based in Rialto,&nbsp;CA location.&nbsp;<\/p>","%category%":"Other","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/50b6838969f2-general-manager","%breezy_id%":"50b6838969f2","%breezy_friendly_id%":"50b6838969f2-general-manager","%breezy_created_date%":"2026-01-20T01:04:14.510Z","%breezy_updated_date%":"2026-01-20T01:06:19.516Z","%_wpgmp_location_city%":"Rialto","%_wpgmp_location_state%":"CA","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Rialto, CA, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"34.1064001","%_wpgmp_metabox_longitude%":"-117.3703235","%rank_math_internal_links_processed%":"1"}},"id":3057,"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    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-mining\/\" name=\"Operations 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 looking for a dynamic and talented mining industry leader to fill a&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\/operations-superintendent-mining\/","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<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 &#8211; Mining","post_link":"https:\/\/turnerstaffing.com\/position\/operations-superintendent-mining\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Mid Level","%location_country%":"United States","%location_city%":"Ely","%location_state_id%":"NV","%location_state_name%":"Nevada","%location_city_state%":"Ely, NV","%education%":"Unspecified","%department%":"Operations","%description%":"<p><strong><u>Turner Mining Group - Project Superintendent<\/u><\/strong><br><\/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\/0baa9194179e-operations-superintendent-mining","%breezy_id%":"0baa9194179e","%breezy_friendly_id%":"0baa9194179e-operations-superintendent-mining","%breezy_created_date%":"2025-10-13T16:46:50.435Z","%breezy_updated_date%":"2026-01-20T17:28:30.249Z","%_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":3056,"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 motivated, detail-oriented&nbsp;Underground Geologist to support ore control and daily production activities at an active mining operation.&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 motivated, detail-oriented&nbsp;Underground Geologist to support ore control and daily production activities at an active mining operation.&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\/geologist-3\/","zoom":19,"extra_fields":{"post_excerpt":"We are seeking a motivated, detail-oriented&nbsp;Underground Geologist to support ore control and daily production activities at an active mining operation.&hellip;","post_content":"<p>We are seeking a motivated, detail-oriented&nbsp;<strong>Underground Geologist<\/strong> to support ore control and daily production activities at an active mining operation. This role is key in ensuring accurate material classification and efficient movement of ore and waste. The Underground Geologist will work closely with operations, survey, and engineering teams to perform in-mine mapping, sampling, material tracking, and data management.<\/p><p><em>10\u201312 month project (may extend based on operational needs)<\/em><br><\/p>\n<h3><strong>Key Responsibilities<\/strong><\/h3>\n<p><strong>Ore Control &amp; Material Management<\/strong><\/p>\n<ul>\n<li>\n<p>Execute daily ore control tasks, including face sampling, muck pile sampling, and material delineation.<\/p>\n<\/li>\n<li>\n<p>Classify ore vs. waste based on sampling and mapping data to guide production decisions.<\/p>\n<\/li>\n<li>\n<p>Monitor tonnage movements and ensure proper routing of material to stockpiles or mill feed.<\/p>\n<\/li>\n<\/ul>\n<p><strong>Underground Geological Mapping &amp; Sampling<\/strong><\/p>\n<ul>\n<li>\n<p>Conduct geological face mapping and update underground maps daily.<\/p>\n<\/li>\n<li>\n<p>Collect channel\/face samples and ensure proper handling, labeling, and chain of custody.<\/p>\n<\/li>\n<li>\n<p>Maintain sampling quality standards and ensure accurate spatial data capture.<\/p>\n<\/li>\n<\/ul>\n<p><strong>Data Entry, Reporting &amp; Interpretation<\/strong><\/p>\n<ul>\n<li>\n<p>Enter sample and geological data into digital databases and ore control software.<\/p>\n<\/li>\n<li>\n<p>Compile daily, weekly, and monthly production reports.<\/p>\n<\/li>\n<li>\n<p>Provide interpretations and observations that support short-term production decisions.<\/p>\n<\/li>\n<\/ul>\n<p><strong>Cross-Department Liaison<\/strong><\/p>\n<ul>\n<li>\n<p>Coordinate with mine operations, survey, engineering, and mill departments to support safe and efficient ore movement.<\/p>\n<\/li>\n<li>\n<p>Communicate material routing plans and updates to shift supervisors and production teams.<\/p>\n<\/li>\n<li>\n<p>Participate in shift handoff meetings and provide clear updates on ore control status.<\/p>\n<\/li>\n<\/ul>\n<h3><strong>Qualifications<\/strong><\/h3>\n<ul>\n<li>\n<p>Bachelor\u2019s degree in Geology, Earth Sciences, or related field.<\/p>\n<\/li>\n<li>\n<p>Previous experience in <strong>underground geology, ore control, or production geology<\/strong> preferred.<\/p>\n<\/li>\n<li>\n<p>Strong mapping, sampling, and geological data interpretation skills.<\/p>\n<\/li>\n<li>\n<p>Proficiency in digital data entry and geological\/ore control software.<\/p>\n<\/li>\n<li>\n<p>Excellent communication and interpersonal skills; able to work effectively cross-functionally.<\/p>\n<\/li>\n<li>\n<p>Ability to work independently underground in a physically demanding environment.<\/p>\n<\/li>\n<li>\n<p>Strong attention to detail and commitment to data accuracy.<\/p><\/li><li><p>Authorized to work in the US without work visa sponsorship.<\/p><\/li><\/ul>","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%":"Winnemucca","%location_state_id%":"NV","%location_state_name%":"Nevada","%location_city_state%":"Winnemucca, NV","%education%":"","%department%":"","%description%":"<p>We are seeking a motivated, detail-oriented&nbsp;<strong>Underground Geologist<\/strong> to support ore control and daily production activities at an active mining operation. This role is key in ensuring accurate material classification and efficient movement of ore and waste. The Underground Geologist will work closely with operations, survey, and engineering teams to perform in-mine mapping, sampling, material tracking, and data management.<\/p><p><em>10\u201312 month project (may extend based on operational needs)<\/em><br><\/p>\n<h3><strong>Key Responsibilities<\/strong><\/h3>\n<p><strong>Ore Control &amp; Material Management<\/strong><\/p>\n<ul>\n<li>\n<p>Execute daily ore control tasks, including face sampling, muck pile sampling, and material delineation.<\/p>\n<\/li>\n<li>\n<p>Classify ore vs. waste based on sampling and mapping data to guide production decisions.<\/p>\n<\/li>\n<li>\n<p>Monitor tonnage movements and ensure proper routing of material to stockpiles or mill feed.<\/p>\n<\/li>\n<\/ul>\n<p><strong>Underground Geological Mapping &amp; Sampling<\/strong><\/p>\n<ul>\n<li>\n<p>Conduct geological face mapping and update underground maps daily.<\/p>\n<\/li>\n<li>\n<p>Collect channel\/face samples and ensure proper handling, labeling, and chain of custody.<\/p>\n<\/li>\n<li>\n<p>Maintain sampling quality standards and ensure accurate spatial data capture.<\/p>\n<\/li>\n<\/ul>\n<p><strong>Data Entry, Reporting &amp; Interpretation<\/strong><\/p>\n<ul>\n<li>\n<p>Enter sample and geological data into digital databases and ore control software.<\/p>\n<\/li>\n<li>\n<p>Compile daily, weekly, and monthly production reports.<\/p>\n<\/li>\n<li>\n<p>Provide interpretations and observations that support short-term production decisions.<\/p>\n<\/li>\n<\/ul>\n<p><strong>Cross-Department Liaison<\/strong><\/p>\n<ul>\n<li>\n<p>Coordinate with mine operations, survey, engineering, and mill departments to support safe and efficient ore movement.<\/p>\n<\/li>\n<li>\n<p>Communicate material routing plans and updates to shift supervisors and production teams.<\/p>\n<\/li>\n<li>\n<p>Participate in shift handoff meetings and provide clear updates on ore control status.<\/p>\n<\/li>\n<\/ul>\n<h3><strong>Qualifications<\/strong><\/h3>\n<ul>\n<li>\n<p>Bachelor\u2019s degree in Geology, Earth Sciences, or related field.<\/p>\n<\/li>\n<li>\n<p>Previous experience in <strong>underground geology, ore control, or production geology<\/strong> preferred.<\/p>\n<\/li>\n<li>\n<p>Strong mapping, sampling, and geological data interpretation skills.<\/p>\n<\/li>\n<li>\n<p>Proficiency in digital data entry and geological\/ore control software.<\/p>\n<\/li>\n<li>\n<p>Excellent communication and interpersonal skills; able to work effectively cross-functionally.<\/p>\n<\/li>\n<li>\n<p>Ability to work independently underground in a physically demanding environment.<\/p>\n<\/li>\n<li>\n<p>Strong attention to detail and commitment to data accuracy.<\/p><\/li><li><p>Authorized to work in the US without work visa sponsorship.<\/p><\/li><\/ul>","%category%":"","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/101ff6b3c4d9-geologist","%breezy_id%":"101ff6b3c4d9","%breezy_friendly_id%":"101ff6b3c4d9-geologist","%breezy_created_date%":"2025-11-05T20:01:55.335Z","%breezy_updated_date%":"2026-01-19T16:21:41.868Z","%_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":3055,"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%":"2026-02-02T13:15:22.15Z","%_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":3048,"infowindow_disable":false},{"source":"post","title":"Mining Plant Electrician","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Mining Plant Electrician\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    The Plant Electrician oversees complex electrical troubleshooting, system upgrades, and control system support. &nbsp;Ensures high reliability of plant electrical systems.&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/mining-plant-electrician\/\" name=\"Mining Plant Electrician\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"The Plant Electrician oversees complex electrical troubleshooting, system upgrades, and control system support. &nbsp;Ensures high reliability of plant electrical systems.&hellip;","address":"Montpelier, VA, USA","location":{"lat":"37.8212538","city":"Montpelier","state":"VA","country":"United States","lng":"-77.6844344","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/mining-plant-electrician\/","zoom":19,"extra_fields":{"post_excerpt":"The Plant Electrician oversees complex electrical troubleshooting, system upgrades, and control system support. &nbsp;Ensures high reliability of plant electrical systems.&hellip;","post_content":"<p>The Plant Electrician oversees complex electrical troubleshooting, system upgrades, and control system support. &nbsp;Ensures high reliability of plant electrical systems. May mentor junior electricians.<\/p>\n<h2>Responsibilities<\/h2>\n<ul><li>Diagnose and repair high- and low-voltage systems, motor controls, and drives.<\/li><li>Install and maintain PLCs, VFDs, and control circuits.<\/li><li>Lead electrical projects and ensure code compliance.<\/li><li>Mentor Electrician I and II personnel and support cross-training.<\/li><li>Interface with automation, engineering, and maintenance teams.<\/li><li>Maintain technical documentation and update panel schematics.<\/li><li>Additional duties as assigned.<\/li><\/ul>\n<h2>Qualifications<\/h2>\n<ul><li>High school diploma or general education degree (GED).<\/li><li>3-5 years of industrial or heavy manufacturing electrical experience.<\/li><li>Proficiency in reading and interpreting complex schematics and control diagrams.<\/li><li>Familiarity with Rockwell, Siemens, or similar PLC platforms.<\/li><li>Licensed or certified as a journeyman electrician preferred.<\/li><li>Strong troubleshooting and decision-making skills.<\/li><li>High level of safety and quality.<\/li><li>Ability to multi-task at a fast-pace (at times), work in outside conditions during all seasons, climb multi-levels by stairs &amp; ladders, work from elevated platforms, use hand tools (shovel, hammer, wrenches, etc.).<\/li><li>Good problem-solving skills.<\/li><li>Mine Safety and Health (MSHA) Knowledge - Preferred.<\/li><li>Forklift experience - Preferred.<\/li><li>Computer Software - Preferred.<\/li><li>Warehouse experience - Preferred.<\/li><\/ul>","post_title":"Mining Plant Electrician","post_link":"https:\/\/turnerstaffing.com\/position\/mining-plant-electrician\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Mid Level","%location_country%":"United States","%location_city%":"Montpelier","%location_state_id%":"VA","%location_state_name%":"Virginia","%location_city_state%":"Montpelier, VA","%education%":"High School or Equivalent","%department%":"","%description%":"<p>The Plant Electrician oversees complex electrical troubleshooting, system upgrades, and control system support. &nbsp;Ensures high reliability of plant electrical systems. May mentor junior electricians.<\/p>\n<h2>Responsibilities<\/h2>\n<ul><li>Diagnose and repair high- and low-voltage systems, motor controls, and drives.<\/li><li>Install and maintain PLCs, VFDs, and control circuits.<\/li><li>Lead electrical projects and ensure code compliance.<\/li><li>Mentor Electrician I and II personnel and support cross-training.<\/li><li>Interface with automation, engineering, and maintenance teams.<\/li><li>Maintain technical documentation and update panel schematics.<\/li><li>Additional duties as assigned.<\/li><\/ul>\n<h2>Qualifications<\/h2>\n<ul><li>High school diploma or general education degree (GED).<\/li><li>3-5 years of industrial or heavy manufacturing electrical experience.<\/li><li>Proficiency in reading and interpreting complex schematics and control diagrams.<\/li><li>Familiarity with Rockwell, Siemens, or similar PLC platforms.<\/li><li>Licensed or certified as a journeyman electrician preferred.<\/li><li>Strong troubleshooting and decision-making skills.<\/li><li>High level of safety and quality.<\/li><li>Ability to multi-task at a fast-pace (at times), work in outside conditions during all seasons, climb multi-levels by stairs &amp; ladders, work from elevated platforms, use hand tools (shovel, hammer, wrenches, etc.).<\/li><li>Good problem-solving skills.<\/li><li>Mine Safety and Health (MSHA) Knowledge - Preferred.<\/li><li>Forklift experience - Preferred.<\/li><li>Computer Software - Preferred.<\/li><li>Warehouse experience - Preferred.<\/li><\/ul>","%category%":"Operations","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/6f7fb742c80d-mining-plant-electrician","%breezy_id%":"6f7fb742c80d","%breezy_friendly_id%":"6f7fb742c80d-mining-plant-electrician","%breezy_created_date%":"2026-01-14T15:13:14.403Z","%breezy_updated_date%":"2026-01-14T15:13:57.333Z","%_wpgmp_location_city%":"Montpelier","%_wpgmp_location_state%":"VA","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Montpelier, VA, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"37.8212538","%_wpgmp_metabox_longitude%":"-77.6844344","%rank_math_internal_links_processed%":"1"}},"id":3044,"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:&nbsp;Heavy Equipment Operator Company:&nbsp;Turner Staffing Group Location:&nbsp;Ruth, NV Position Type:&nbsp;Full-Time About Us:&nbsp;Turner Staffing Group, in collaboration with our esteemed&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/heavy-equipment-operator-3\/\" name=\"Heavy Equipment Operator\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Job Title:&nbsp;Heavy Equipment Operator Company:&nbsp;Turner Staffing Group Location:&nbsp;Ruth, NV Position Type:&nbsp;Full-Time About Us:&nbsp;Turner Staffing Group, in collaboration with our esteemed&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\/heavy-equipment-operator-3\/","zoom":19,"extra_fields":{"post_excerpt":"Job Title:&nbsp;Heavy Equipment Operator Company:&nbsp;Turner Staffing Group Location:&nbsp;Ruth, NV Position Type:&nbsp;Full-Time About Us:&nbsp;Turner Staffing Group, in collaboration with our esteemed&hellip;","post_content":"<p><strong>Job Title:<\/strong>&nbsp;Heavy Equipment Operator<\/p>\n<p><strong>Company:<\/strong>&nbsp;Turner Staffing Group<\/p>\n<p><strong>Location:<\/strong>&nbsp;Ruth, NV<\/p>\n<p><strong>Position Type:<\/strong>&nbsp;Full-Time<\/p>\n<p><strong>About Us:<\/strong>&nbsp;Turner Staffing Group, in collaboration with our esteemed mining partner in Ruth, NV, 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>&nbsp;We 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><\/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-3\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Associate","%location_country%":"United States","%location_city%":"Ely","%location_state_id%":"NV","%location_state_name%":"Nevada","%location_city_state%":"Ely, NV","%education%":"High School or equivalent","%department%":"Operations","%description%":"<p><strong>Job Title:<\/strong>&nbsp;Heavy Equipment Operator<\/p>\n<p><strong>Company:<\/strong>&nbsp;Turner Staffing Group<\/p>\n<p><strong>Location:<\/strong>&nbsp;Ruth, NV<\/p>\n<p><strong>Position Type:<\/strong>&nbsp;Full-Time<\/p>\n<p><strong>About Us:<\/strong>&nbsp;Turner Staffing Group, in collaboration with our esteemed mining partner in Ruth, NV, 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>&nbsp;We 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><\/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\/273e0522a991-heavy-equipment-operator","%breezy_id%":"273e0522a991","%breezy_friendly_id%":"273e0522a991-heavy-equipment-operator","%breezy_created_date%":"2026-01-14T19:18:07.296Z","%breezy_updated_date%":"2026-02-04T15:53:48.859Z","%_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":3046,"infowindow_disable":false},{"source":"post","title":"Equipment Operator","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Equipment Operator\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Equipment Operator &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; Reports to: Foreman \u2013 Turner Mining Group Job Description: The Equipment Operator is a skilled mining operator&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/equipment-operator-2\/\" name=\"Equipment Operator\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Equipment Operator &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; Reports to: Foreman \u2013 Turner Mining Group Job Description: The Equipment Operator is a skilled mining operator&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\/equipment-operator-2\/","zoom":19,"extra_fields":{"post_excerpt":"Equipment Operator &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; Reports to: Foreman \u2013 Turner Mining Group Job Description: The Equipment Operator is a skilled mining operator&hellip;","post_content":"<p><strong>Equipment Operator<\/strong>                &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&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><strong>Reports to: <\/strong><strong>Foreman \u2013 Turner Mining Group<\/strong><\/p>\n<p><strong>Job Description:<\/strong><\/p>\n<p>The Equipment Operator is a skilled mining operator position within Turner Mining Group. The successful candidate must live the Turner Values and be an outward example to others. This position must demonstrate a strong commitment to \u201cSafe Production\u201d through decision making, priorities, and client relations.<\/p>\n<p><strong>Objectives and Contributions:<\/strong><\/p>\n<p>The Equipment Operator is focused on key aspects that drive communication and safe production while maintaining a high level of efficiency, and preventative maintenance awareness requirements. The Operator demonstrates safety ownership at a personal level and holds other crew members to the same high standard.&nbsp; The Equipment Operator will train and develop into the Senior Equipment Operator job scope while the Senior Equipment operator is filling in for the Lead job duties. <\/p>\n<ul><li>Work with employees to ensure a high level of accuracy and engagement on hazard identification and control<\/li><li>Engage crews and leadership to define processes that motivate working towards common goals<\/li><li>Assist with MSHA regulatory task training and verify compliance to standards<\/li><li>Live the values as part of a visible daily decision-making process<\/li><li>Assist with training proficiency audits<\/li><li>Involvement in risk assessment processes at various levels of the organization<\/li><li>Holds themselves and others accountable for acting like an owner (taking care of equipment, not wasting resources, using time wisely, and being accountable for conditions and behaviors)<\/li><li>Maintains a high standard of housekeeping (machine and work areas)<\/li><\/ul>\n<p><u>Culture and Communication:<\/u><\/p>\n<ul><li>Can effectively communicate in English (multi-lingual preferred)<\/li><li>Participate in site and project leaders to identify areas of improvement<\/li><li>Work with crews to support proactive near miss reporting<\/li><li>Leads by example (walks the talk)<\/li><\/ul>\n<p><u>Systems:<\/u><\/p>\n<ul><li>Ability to perform quality pre-operation machine inspections (Based on mobile equipment physical demands analysis)<\/li><li>Accurately documents 5000-23 and training checklist requirements<\/li><li>Other regulatory &amp; internal \/ external forms as required<\/li><\/ul>\n<p><u>Travel and New Site Development:<\/u><\/p>\n<ul><li>Maintains a valid and insurable driving license<\/li><li>Available to travel on short notice to support timelines and production requirements at existing sites<\/li><\/ul>\n<p><u>Time and Interactions:<\/u><\/p>\n<ul><li>The Equipment Operator must be flexible on shift schedules (days and nights) to assist with training and production needs<\/li><li>The Equipment Operator will be self-starting, motivated, with a strong desire to be part of a team and to influence improvement. Communication is also critical to keep leadership and site-based personnel in the loop of successes, challenges, and any additional support that may be required<\/li><li>Excellent time management skills<\/li><\/ul>\n<p><u>Qualifications:<\/u><\/p>\n<ul><li>Willingness and ability to adhere to OSHA \/ MSHA regulatory requirements<\/li><li>1-3 years\u2019 experience in mining \/ heavy industry preferred<\/li><li>Working knowledge of safety systems and processes<\/li><li>Appropriate attention to detail required<\/li><li>Strong communication skills<\/li><li>Strong morals and values<\/li><li>Exemplary attendance record<\/li><li>Exemplary safety and disciplinary record<\/li><li>Willingness to be flexible on daily job duty requirements<\/li><li>Maintains a positive outspoken learning attitude<\/li><li>The Equipment Operator must pass and maintain Turner Mining Group mobile equipment skills qualifications on each piece of the following equipment:<ul><li><strong>Support excavator<\/strong><\/li><li><strong>Dozer<\/strong><\/li><li><strong>Support loader <\/strong><\/li><li><strong>Grader<\/strong><\/li><li><strong>Water truck<\/strong><\/li><li><strong>Haulage truck<\/strong><\/li><\/ul><\/li><\/ul>\n<p><u>Other Duties:<\/u><\/p>\n<p>In addition to the job skills above, there may be requirements for manual tasks to be completed to mee other business needs. Operators in any job duty classification may be required to participate in these additional tasks.&nbsp;<\/p>","post_title":"Equipment Operator","post_link":"https:\/\/turnerstaffing.com\/position\/equipment-operator-2\/","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%":"Unspecified","%department%":"Operations","%description%":"<p><strong>Equipment Operator<\/strong>                &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&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><strong>Reports to: <\/strong><strong>Foreman \u2013 Turner Mining Group<\/strong><\/p>\n<p><strong>Job Description:<\/strong><\/p>\n<p>The Equipment Operator is a skilled mining operator position within Turner Mining Group. The successful candidate must live the Turner Values and be an outward example to others. This position must demonstrate a strong commitment to \u201cSafe Production\u201d through decision making, priorities, and client relations.<\/p>\n<p><strong>Objectives and Contributions:<\/strong><\/p>\n<p>The Equipment Operator is focused on key aspects that drive communication and safe production while maintaining a high level of efficiency, and preventative maintenance awareness requirements. The Operator demonstrates safety ownership at a personal level and holds other crew members to the same high standard.&nbsp; The Equipment Operator will train and develop into the Senior Equipment Operator job scope while the Senior Equipment operator is filling in for the Lead job duties. <\/p>\n<ul><li>Work with employees to ensure a high level of accuracy and engagement on hazard identification and control<\/li><li>Engage crews and leadership to define processes that motivate working towards common goals<\/li><li>Assist with MSHA regulatory task training and verify compliance to standards<\/li><li>Live the values as part of a visible daily decision-making process<\/li><li>Assist with training proficiency audits<\/li><li>Involvement in risk assessment processes at various levels of the organization<\/li><li>Holds themselves and others accountable for acting like an owner (taking care of equipment, not wasting resources, using time wisely, and being accountable for conditions and behaviors)<\/li><li>Maintains a high standard of housekeeping (machine and work areas)<\/li><\/ul>\n<p><u>Culture and Communication:<\/u><\/p>\n<ul><li>Can effectively communicate in English (multi-lingual preferred)<\/li><li>Participate in site and project leaders to identify areas of improvement<\/li><li>Work with crews to support proactive near miss reporting<\/li><li>Leads by example (walks the talk)<\/li><\/ul>\n<p><u>Systems:<\/u><\/p>\n<ul><li>Ability to perform quality pre-operation machine inspections (Based on mobile equipment physical demands analysis)<\/li><li>Accurately documents 5000-23 and training checklist requirements<\/li><li>Other regulatory &amp; internal \/ external forms as required<\/li><\/ul>\n<p><u>Travel and New Site Development:<\/u><\/p>\n<ul><li>Maintains a valid and insurable driving license<\/li><li>Available to travel on short notice to support timelines and production requirements at existing sites<\/li><\/ul>\n<p><u>Time and Interactions:<\/u><\/p>\n<ul><li>The Equipment Operator must be flexible on shift schedules (days and nights) to assist with training and production needs<\/li><li>The Equipment Operator will be self-starting, motivated, with a strong desire to be part of a team and to influence improvement. Communication is also critical to keep leadership and site-based personnel in the loop of successes, challenges, and any additional support that may be required<\/li><li>Excellent time management skills<\/li><\/ul>\n<p><u>Qualifications:<\/u><\/p>\n<ul><li>Willingness and ability to adhere to OSHA \/ MSHA regulatory requirements<\/li><li>1-3 years\u2019 experience in mining \/ heavy industry preferred<\/li><li>Working knowledge of safety systems and processes<\/li><li>Appropriate attention to detail required<\/li><li>Strong communication skills<\/li><li>Strong morals and values<\/li><li>Exemplary attendance record<\/li><li>Exemplary safety and disciplinary record<\/li><li>Willingness to be flexible on daily job duty requirements<\/li><li>Maintains a positive outspoken learning attitude<\/li><li>The Equipment Operator must pass and maintain Turner Mining Group mobile equipment skills qualifications on each piece of the following equipment:<ul><li><strong>Support excavator<\/strong><\/li><li><strong>Dozer<\/strong><\/li><li><strong>Support loader <\/strong><\/li><li><strong>Grader<\/strong><\/li><li><strong>Water truck<\/strong><\/li><li><strong>Haulage truck<\/strong><\/li><\/ul><\/li><\/ul>\n<p><u>Other Duties:<\/u><\/p>\n<p>In addition to the job skills above, there may be requirements for manual tasks to be completed to mee other business needs. Operators in any job duty classification may be required to participate in these additional tasks.&nbsp;<\/p>","%category%":"Operations","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/dab105508554-equipment-operator","%breezy_id%":"dab105508554","%breezy_friendly_id%":"dab105508554-equipment-operator","%breezy_created_date%":"2026-01-14T19:22:17.533Z","%breezy_updated_date%":"2026-01-27T02:17:04.059Z","%_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":3047,"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 motivated, detail-oriented Underground Geologist to support ore control and daily production activities at an active mining&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 motivated, detail-oriented Underground Geologist to support ore control and daily production activities at an active mining&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 motivated, detail-oriented Underground Geologist to support ore control and daily production activities at an active mining&hellip;","post_content":"<p style=\"color:#222222\">We are seeking a motivated, detail-oriented Underground Geologist to support ore control and daily production activities at an active mining operation. This role is key in ensuring accurate material classification and efficient movement of ore and waste. The Underground Geologist will work closely with operations, survey, and engineering teams to perform in-mine mapping, sampling, material tracking, and data management.<\/p><p style=\"color:#222222\"><em>10&ndash;12 month project (may extend based on operational needs)<\/em><\/p><p style=\"color:#222222\">Key Responsibilities<\/p><p style=\"color:#222222\">Ore Control &amp; Material Management<\/p><ul><li><p>Execute daily ore control tasks, including face sampling, muck pile sampling, and material delineation.<\/p><\/li><li><p>Classify ore vs. waste based on sampling and mapping data to guide production decisions.<\/p><\/li><li><p>Monitor tonnage movements and ensure proper routing of material to stockpiles or mill feed.<\/p><\/li><\/ul><p style=\"color:#222222\">Underground Geological Mapping &amp; Sampling<\/p><ul><li><p>Conduct geological face mapping and update underground maps daily.<\/p><\/li><li><p>Collect channel\/face samples and ensure proper handling, labeling, and chain of custody.<\/p><\/li><li><p>Maintain sampling quality standards and ensure accurate spatial data capture.<\/p><\/li><\/ul><p style=\"color:#222222\">Data Entry, Reporting &amp; Interpretation<\/p><ul><li><p>Enter sample and geological data into digital databases and ore control software.<\/p><\/li><li><p>Compile daily, weekly, and monthly production reports.<\/p><\/li><li><p>Provide interpretations and observations that support short-term production decisions.<\/p><\/li><\/ul><p style=\"color:#222222\">Cross-Department Liaison<\/p><ul><li><p>Coordinate with mine operations, survey, engineering, and mill departments to support safe and efficient ore movement.<\/p><\/li><li><p>Communicate material routing plans and updates to shift supervisors and production teams.<\/p><\/li><li><p>Participate in shift handoff meetings and provide clear updates on ore control status.<\/p><\/li><\/ul><p style=\"color:#222222\">Qualifications<\/p><ul><li><p>Bachelor&rsquo;s degree in Geology, Earth Sciences, or related field.<\/p><\/li><li><p>Previous experience in underground geology, ore control, or production geology preferred.<\/p><\/li><li><p>Strong mapping, sampling, and geological data interpretation skills.<\/p><\/li><li><p>Proficiency in digital data entry and geological\/ore control software.<\/p><\/li><li><p>Excellent communication and interpersonal skills; able to work effectively cross-functionally.<\/p><\/li><li><p>Ability to work independently underground in a physically demanding environment.<\/p><\/li><li><p>Strong attention to detail and commitment to data accuracy.<\/p><\/li><li><p>Authorized to work in the US without work visa sponsorship.<\/p><\/li><\/ul>","post_title":"Geologist","post_link":"https:\/\/turnerstaffing.com\/position\/geologist\/","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:#222222;\">We are seeking a motivated, detail-oriented Underground Geologist to support ore control and daily production activities at an active mining operation. This role is key in ensuring accurate material classification and efficient movement of ore and waste. The Underground Geologist will work closely with operations, survey, and engineering teams to perform in-mine mapping, sampling, material tracking, and data management.<\/p><p style=\"color:#222222;\"><em>10&ndash;12 month project (may extend based on operational needs)<\/em><\/p><p style=\"color:#222222;\">Key Responsibilities<\/p><p style=\"color:#222222;\">Ore Control &amp; Material Management<\/p><ul><li><p>Execute daily ore control tasks, including face sampling, muck pile sampling, and material delineation.<\/p><\/li><li><p>Classify ore vs. waste based on sampling and mapping data to guide production decisions.<\/p><\/li><li><p>Monitor tonnage movements and ensure proper routing of material to stockpiles or mill feed.<\/p><\/li><\/ul><p style=\"color:#222222;\">Underground Geological Mapping &amp; Sampling<\/p><ul><li><p>Conduct geological face mapping and update underground maps daily.<\/p><\/li><li><p>Collect channel\/face samples and ensure proper handling, labeling, and chain of custody.<\/p><\/li><li><p>Maintain sampling quality standards and ensure accurate spatial data capture.<\/p><\/li><\/ul><p style=\"color:#222222;\">Data Entry, Reporting &amp; Interpretation<\/p><ul><li><p>Enter sample and geological data into digital databases and ore control software.<\/p><\/li><li><p>Compile daily, weekly, and monthly production reports.<\/p><\/li><li><p>Provide interpretations and observations that support short-term production decisions.<\/p><\/li><\/ul><p style=\"color:#222222;\">Cross-Department Liaison<\/p><ul><li><p>Coordinate with mine operations, survey, engineering, and mill departments to support safe and efficient ore movement.<\/p><\/li><li><p>Communicate material routing plans and updates to shift supervisors and production teams.<\/p><\/li><li><p>Participate in shift handoff meetings and provide clear updates on ore control status.<\/p><\/li><\/ul><p style=\"color:#222222;\">Qualifications<\/p><ul><li><p>Bachelor&rsquo;s degree in Geology, Earth Sciences, or related field.<\/p><\/li><li><p>Previous experience in underground geology, ore control, or production geology preferred.<\/p><\/li><li><p>Strong mapping, sampling, and geological data interpretation skills.<\/p><\/li><li><p>Proficiency in digital data entry and geological\/ore control software.<\/p><\/li><li><p>Excellent communication and interpersonal skills; able to work effectively cross-functionally.<\/p><\/li><li><p>Ability to work independently underground in a physically demanding environment.<\/p><\/li><li><p>Strong attention to detail and commitment to data accuracy.<\/p><\/li><li><p>Authorized to work in the US without work visa sponsorship.<\/p><\/li><\/ul>","%application_url%":"https:\/\/jobs.crelate.com\/portal\/turnerstaffinggroup\/job\/yixertu1ihhmbeq3u3zx7qfiwh","%crelate_id%":"yixertu1ihhmbeq3u3zx7qfiwh","%crelate_created_date%":"2026-01-13T14:19:57.59Z","%crelate_updated_date%":"2026-02-04T00:32:43.51Z","%_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":3043,"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-3\/\" 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-3\/","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-3\/","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\/c918fc52f64c-haul-truck-operator-mining","%breezy_id%":"c918fc52f64c","%breezy_friendly_id%":"c918fc52f64c-haul-truck-operator-mining","%breezy_created_date%":"2026-01-13T21:57:58.188Z","%breezy_updated_date%":"2026-01-13T21:58:19.940Z","%_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":3039,"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-2\/\" 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-2\/","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-2\/","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\/8ca66b03abcc-heavy-equipment-fuel-lube-technician","%breezy_id%":"8ca66b03abcc","%breezy_friendly_id%":"8ca66b03abcc-heavy-equipment-fuel-lube-technician","%breezy_created_date%":"2026-01-13T21:58:29.788Z","%breezy_updated_date%":"2026-01-13T21:58:48.305Z","%_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":3040,"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-8\/\" 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-8\/","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-8\/","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\/2033ab5dd5b4-heavy-equipment-operator","%breezy_id%":"2033ab5dd5b4","%breezy_friendly_id%":"2033ab5dd5b4-heavy-equipment-operator","%breezy_created_date%":"2026-01-13T21:59:13.595Z","%breezy_updated_date%":"2026-01-13T21:59:34.319Z","%_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":3041,"infowindow_disable":false},{"source":"post","title":"Geological Technician","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Geological Technician\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Job Summary Turner Staffing Group is seeking a reliable and detail-oriented Sample Technician to support one of our mining partners&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/geological-technician\/\" name=\"Geological Technician\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Job Summary Turner Staffing Group is seeking a reliable and detail-oriented Sample Technician to support one of our mining partners&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\/geological-technician\/","zoom":19,"extra_fields":{"post_excerpt":"Job Summary Turner Staffing Group is seeking a reliable and detail-oriented Sample Technician to support one of our mining partners&hellip;","post_content":"<h4>Job Summary<\/h4>\n<p>Turner Staffing Group is seeking a reliable and detail-oriented <strong>Sample Technician<\/strong> to support one of our mining partners in Kershaw, SC. This role is responsible for the safe handling, tracking, and disposal of geological samples to support ongoing production and exploration activities. The ideal candidate is safety-focused, organized, and comfortable operating mobile equipment in an industrial environment.<\/p>\n<h4>Key Responsibilities<\/h4>\n<ul>\n<li>\n<p>Unload geological samples from pickup trucks in a safe and efficient manner<\/p>\n<\/li>\n<li>\n<p>Sort samples by designated pattern and priority onto sample tables<\/p>\n<\/li>\n<li>\n<p>Dump samples into sample trays and load trays onto drying oven racks<\/p>\n<\/li>\n<li>\n<p>Place and remove drying oven racks into and out of drying ovens as required<\/p>\n<\/li>\n<li>\n<p>Accurately track and update sample status throughout the shift<\/p>\n<\/li>\n<li>\n<p>Operate a forklift to load processed sample pulps into a dump truck<\/p>\n<\/li>\n<li>\n<p>Operate a dump truck to safely dispose of sample pulps in designated areas<\/p>\n<\/li>\n<li>\n<p>Maintain a clean, organized, and safe work area in compliance with site safety standards<\/p>\n<\/li>\n<\/ul>\n<h4>Qualifications &amp; Skills<\/h4>\n<ul>\n<li>\n<p>Previous experience in mining, sample preparation, laboratory, or industrial environments preferred<\/p>\n<\/li>\n<li>\n<p>Forklift and dump truck operating experience required or ability to become certified on site<\/p>\n<\/li>\n<li>\n<p>Strong attention to detail and ability to follow sample handling procedures<\/p>\n<\/li>\n<li>\n<p>Ability to work in a physically demanding environment, including lifting and standing for extended periods<\/p>\n<\/li>\n<li>\n<p>Commitment to safety and compliance with all site policies and procedures<\/p>\n<\/li>\n<\/ul>\n<h4>Work Environment<\/h4>\n<ul>\n<li>\n<p>Surface mine and sample preparation facility<\/p>\n<\/li>\n<li>\n<p>Exposure to industrial equipment, noise, dust, and heat from drying ovens<\/p>\n<\/li>\n<li>\n<p>Requires use of appropriate personal protective equipment (PPE)<\/p><\/li><\/ul>\n<p><\/p>","post_title":"Geological Technician","post_link":"https:\/\/turnerstaffing.com\/position\/geological-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%":"<h4>Job Summary<\/h4>\n<p>Turner Staffing Group is seeking a reliable and detail-oriented <strong>Sample Technician<\/strong> to support one of our mining partners in Kershaw, SC. This role is responsible for the safe handling, tracking, and disposal of geological samples to support ongoing production and exploration activities. The ideal candidate is safety-focused, organized, and comfortable operating mobile equipment in an industrial environment.<\/p>\n<h4>Key Responsibilities<\/h4>\n<ul>\n<li>\n<p>Unload geological samples from pickup trucks in a safe and efficient manner<\/p>\n<\/li>\n<li>\n<p>Sort samples by designated pattern and priority onto sample tables<\/p>\n<\/li>\n<li>\n<p>Dump samples into sample trays and load trays onto drying oven racks<\/p>\n<\/li>\n<li>\n<p>Place and remove drying oven racks into and out of drying ovens as required<\/p>\n<\/li>\n<li>\n<p>Accurately track and update sample status throughout the shift<\/p>\n<\/li>\n<li>\n<p>Operate a forklift to load processed sample pulps into a dump truck<\/p>\n<\/li>\n<li>\n<p>Operate a dump truck to safely dispose of sample pulps in designated areas<\/p>\n<\/li>\n<li>\n<p>Maintain a clean, organized, and safe work area in compliance with site safety standards<\/p>\n<\/li>\n<\/ul>\n<h4>Qualifications &amp; Skills<\/h4>\n<ul>\n<li>\n<p>Previous experience in mining, sample preparation, laboratory, or industrial environments preferred<\/p>\n<\/li>\n<li>\n<p>Forklift and dump truck operating experience required or ability to become certified on site<\/p>\n<\/li>\n<li>\n<p>Strong attention to detail and ability to follow sample handling procedures<\/p>\n<\/li>\n<li>\n<p>Ability to work in a physically demanding environment, including lifting and standing for extended periods<\/p>\n<\/li>\n<li>\n<p>Commitment to safety and compliance with all site policies and procedures<\/p>\n<\/li>\n<\/ul>\n<h4>Work Environment<\/h4>\n<ul>\n<li>\n<p>Surface mine and sample preparation facility<\/p>\n<\/li>\n<li>\n<p>Exposure to industrial equipment, noise, dust, and heat from drying ovens<\/p>\n<\/li>\n<li>\n<p>Requires use of appropriate personal protective equipment (PPE)<\/p><\/li><\/ul>\n<p><\/p>","%category%":"","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/b7a806b9cdd1-geological-technician","%breezy_id%":"b7a806b9cdd1","%breezy_friendly_id%":"b7a806b9cdd1-geological-technician","%breezy_created_date%":"2026-01-13T22:00:17.377Z","%breezy_updated_date%":"2026-01-13T22:00:27.775Z","%_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":3042,"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-2\/\" 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-2\/","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-2\/","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\/14a7b7187a6a-excavator-operator","%breezy_id%":"14a7b7187a6a","%breezy_friendly_id%":"14a7b7187a6a-excavator-operator","%breezy_created_date%":"2026-01-13T21:54:59.024Z","%breezy_updated_date%":"2026-01-19T17:16:09.359Z","%_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":3037,"infowindow_disable":false},{"source":"post","title":"General Laborer &#8211; Mining","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    General Laborer &#8211; Mining\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Turner Staffing Group \u2013 General Laborer Responsibilities:&nbsp; Laborer duties include directional flagging of heavy and light duty traffic, stormwater BMP&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/general-laborer-mining-2\/\" name=\"General Laborer &#8211; Mining\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Turner Staffing Group \u2013 General Laborer Responsibilities:&nbsp; Laborer duties include directional flagging of heavy and light duty traffic, stormwater BMP&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\/general-laborer-mining-2\/","zoom":19,"extra_fields":{"post_excerpt":"Turner Staffing Group \u2013 General Laborer Responsibilities:&nbsp; Laborer duties include directional flagging of heavy and light duty traffic, stormwater BMP&hellip;","post_content":"<p><strong><u>Turner Staffing Group \u2013 General Laborer<\/u><\/strong><br><\/p>\n<p><strong>Responsibilities:&nbsp;<\/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 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.<\/p>\n<p>At Turner Staffing&nbsp;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":"General Laborer &#8211; Mining","post_link":"https:\/\/turnerstaffing.com\/position\/general-laborer-mining-2\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Entry Level","%location_country%":"United States","%location_city%":"Kershaw","%location_state_id%":"SC","%location_state_name%":"South Carolina","%location_city_state%":"Kershaw, SC","%education%":"Unspecified","%department%":"","%description%":"<p><strong><u>Turner Staffing Group \u2013 General Laborer<\/u><\/strong><br><\/p>\n<p><strong>Responsibilities:&nbsp;<\/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 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.<\/p>\n<p>At Turner Staffing&nbsp;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\/9b015675f185-general-laborer-mining","%breezy_id%":"9b015675f185","%breezy_friendly_id%":"9b015675f185-general-laborer-mining","%breezy_created_date%":"2026-01-13T21:55:23.334Z","%breezy_updated_date%":"2026-01-13T21:55:54.787Z","%_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":3038,"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    Turner Staffing Group is seeking two to four&nbsp;Light Vehicle Mechanics to support a high-priority maintenance project for one of our&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/light-vehicle-mechanic-4\/\" name=\"Light Vehicle Mechanic\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Turner Staffing Group is seeking two to four&nbsp;Light Vehicle Mechanics to support a high-priority maintenance project for one of our&hellip;","address":"Clayton, ID, USA","location":{"lat":"44.2592165","city":"Clayton","state":"ID","country":"United States","lng":"-114.4011538","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/light-vehicle-mechanic-4\/","zoom":19,"extra_fields":{"post_excerpt":"Turner Staffing Group is seeking two to four&nbsp;Light Vehicle Mechanics to support a high-priority maintenance project for one of our&hellip;","post_content":"<p>Turner Staffing Group is seeking two to four<strong>&nbsp;Light Vehicle Mechanics<\/strong> to support a high-priority maintenance project for one of our <strong>mining industry clients<\/strong> in the <strong>Clayton, Idaho<\/strong> area. These are <strong>on-site, project-based <\/strong><strong>(3-6 month)&nbsp;<\/strong><strong>roles with a rotating schedule and competitive pay, ideal for mechanics <\/strong>ready to step into immediate, impactful work.<\/p><p><strong><strong>Role Overview<\/strong><\/strong><\/p><p>As a Light Vehicle Mechanic, you will support site operations by maintaining and repairing light-duty vehicles and mobile equipment used in an active mining environment. Safety, reliability, and rapid turnaround are critical to this role.<\/p><p><strong><strong>Key Responsibilities<\/strong><\/strong><\/p><ul><li><p>Diagnose, service, and repair, and maintain light-duty vehicles and site fleet equipment<\/p><\/li><li><p>Perform preventive maintenance and inspections<\/p><\/li><li><p>Troubleshoot mechanical, electrical, and hydraulic systems<\/p><\/li><li><p>Document repairs and maintenance activities accurately<\/p><\/li><li><p>Ensure all work is performed in compliance with safety standards and procedures<\/p><\/li><li><p>Support site operations by responding to urgent maintenance needs<\/p><\/li><\/ul><p><strong><strong>Required Qualifications<\/strong><\/strong><\/p><ul><li><p>Proven experience as a <strong>Light Vehicle Mechanic<\/strong> (mining or industrial experience preferred)<\/p><\/li><li><p>Strong troubleshooting and diagnostic skills<\/p><\/li><li><p>Ability to work a <strong>7\/7 rotating schedule<\/strong><\/p><\/li><li><p>Commitment to safety and quality workmanship<\/p><\/li><li><p>Must be authorized to work in the U.S. without visa sponsorship<\/p><\/li><\/ul><p><strong><strong>Preferred Qualifications<\/strong><\/strong><\/p><ul><li><p>Experience working in mining or heavy industrial environments<\/p><\/li><li><p>ASE certifications or equivalent trade credentials<\/p><\/li><li><p>Ability to work independently in a fast-paced site environment<\/p><\/li><\/ul><p><strong><strong>What Turner Staffing Group Offers<\/strong><\/strong><\/p><ul><li><p>Opportunity to support a high-priority project with immediate impact<\/p><\/li><li><p>Work with a respected staffing partner supporting critical mining operations<\/p><\/li><li><p>Exposure to project-based roles with potential for future assignments<\/p><\/li><\/ul><p><strong><strong>Apply Now<\/strong><\/strong><\/p><p>If you are a skilled light vehicle mechanic ready to take on a short-term, high-impact project, we encourage you to apply.<\/p><p><strong>Turner Staffing Group is an equal opportunity employer.<\/strong><\/p>","post_title":"Light Vehicle Mechanic","post_link":"https:\/\/turnerstaffing.com\/position\/light-vehicle-mechanic-4\/","post_featured_image":"","post_categories":"","post_tags":"","%location_country%":"United States","%location_city%":"Clayton","%location_state_id%":"ID","%location_city_state%":"Clayton, ID","%description%":"<p>Turner Staffing Group is seeking two to four<strong>&nbsp;Light Vehicle Mechanics<\/strong> to support a high-priority maintenance project for one of our <strong>mining industry clients<\/strong> in the <strong>Clayton, Idaho<\/strong> area. These are <strong>on-site, project-based <\/strong><strong>(3-6 month)&nbsp;<\/strong><strong>roles with a rotating schedule and competitive pay, ideal for mechanics <\/strong>ready to step into immediate, impactful work.<\/p><p><strong><strong>Role Overview<\/strong><\/strong><\/p><p>As a Light Vehicle Mechanic, you will support site operations by maintaining and repairing light-duty vehicles and mobile equipment used in an active mining environment. Safety, reliability, and rapid turnaround are critical to this role.<\/p><p><strong><strong>Key Responsibilities<\/strong><\/strong><\/p><ul><li><p>Diagnose, service, and repair, and maintain light-duty vehicles and site fleet equipment<\/p><\/li><li><p>Perform preventive maintenance and inspections<\/p><\/li><li><p>Troubleshoot mechanical, electrical, and hydraulic systems<\/p><\/li><li><p>Document repairs and maintenance activities accurately<\/p><\/li><li><p>Ensure all work is performed in compliance with safety standards and procedures<\/p><\/li><li><p>Support site operations by responding to urgent maintenance needs<\/p><\/li><\/ul><p><strong><strong>Required Qualifications<\/strong><\/strong><\/p><ul><li><p>Proven experience as a <strong>Light Vehicle Mechanic<\/strong> (mining or industrial experience preferred)<\/p><\/li><li><p>Strong troubleshooting and diagnostic skills<\/p><\/li><li><p>Ability to work a <strong>7\/7 rotating schedule<\/strong><\/p><\/li><li><p>Commitment to safety and quality workmanship<\/p><\/li><li><p>Must be authorized to work in the U.S. without visa sponsorship<\/p><\/li><\/ul><p><strong><strong>Preferred Qualifications<\/strong><\/strong><\/p><ul><li><p>Experience working in mining or heavy industrial environments<\/p><\/li><li><p>ASE certifications or equivalent trade credentials<\/p><\/li><li><p>Ability to work independently in a fast-paced site environment<\/p><\/li><\/ul><p><strong><strong>What Turner Staffing Group Offers<\/strong><\/strong><\/p><ul><li><p>Opportunity to support a high-priority project with immediate impact<\/p><\/li><li><p>Work with a respected staffing partner supporting critical mining operations<\/p><\/li><li><p>Exposure to project-based roles with potential for future assignments<\/p><\/li><\/ul><p><strong><strong>Apply Now<\/strong><\/strong><\/p><p>If you are a skilled light vehicle mechanic ready to take on a short-term, high-impact project, we encourage you to apply.<\/p><p><strong>Turner Staffing Group is an equal opportunity employer.<\/strong><\/p>","%application_url%":"https:\/\/jobs.crelate.com\/portal\/turnerstaffinggroup\/job\/3iudsanbutj1i7su6op66picio","%crelate_id%":"3iudsanbutj1i7su6op66picio","%crelate_created_date%":"2026-01-08T21:00:17.54Z","%crelate_updated_date%":"2026-02-02T13:12:51.42Z","%_wpgmp_location_city%":"Clayton","%_wpgmp_location_state%":"ID","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Clayton, ID, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"44.2592165","%_wpgmp_metabox_longitude%":"-114.4011538","%rank_math_internal_links_processed%":"1"}},"id":3036,"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    Turner Staffing Group is seeking two to four&nbsp;Light Vehicle Mechanics&nbsp;to support a high-priority maintenance project for one of our&nbsp;mining industry&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/light-vehicle-mechanic-3\/\" name=\"Light Vehicle Mechanic\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Turner Staffing Group is seeking two to four&nbsp;Light Vehicle Mechanics&nbsp;to support a high-priority maintenance project for one of our&nbsp;mining industry&hellip;","address":"Clayton, ID, USA","location":{"lat":"44.2592165","city":"Clayton","state":"ID","country":"United States","lng":"-114.4011538","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/light-vehicle-mechanic-3\/","zoom":19,"extra_fields":{"post_excerpt":"Turner Staffing Group is seeking two to four&nbsp;Light Vehicle Mechanics&nbsp;to support a high-priority maintenance project for one of our&nbsp;mining industry&hellip;","post_content":"<p>Turner Staffing Group is seeking two to four<strong>&nbsp;Light Vehicle Mechanics<\/strong>&nbsp;to support a high-priority maintenance project for one of our&nbsp;<strong>mining industry clients<\/strong>&nbsp;in the&nbsp;<strong>Clayton, Idaho<\/strong>&nbsp;area. These are&nbsp;<strong>on-site, project-based&nbsp;<\/strong><strong>(3-6 month)&nbsp;<\/strong><strong>roles with a rotating schedule and competitive pay, ideal for mechanics&nbsp;<\/strong>ready to step into immediate, impactful work.<\/p>\n<p><strong><strong>Role Overview<\/strong><\/strong><\/p>\n<p>As a Light Vehicle Mechanic, you will support site operations by maintaining and repairing light-duty vehicles and mobile equipment used in an active mining environment. Safety, reliability, and rapid turnaround are critical to this role.<\/p>\n<p><strong><strong>Key Responsibilities<\/strong><\/strong><\/p>\n<ul><li>Diagnose, service, and repair, and maintain light-duty vehicles and site fleet equipment<\/li><li>Perform preventive maintenance and inspections<\/li><li>Troubleshoot mechanical, electrical, and hydraulic systems<\/li><li>Document repairs and maintenance activities accurately<\/li><li>Ensure all work is performed in compliance with safety standards and procedures<\/li><li>Support site operations by responding to urgent maintenance needs<\/li><\/ul>\n<p><strong><strong>Required Qualifications<\/strong><\/strong><\/p>\n<ul><li>Proven experience as a&nbsp;<strong>Light Vehicle Mechanic<\/strong>&nbsp;(mining or industrial experience preferred)<\/li><li>Strong troubleshooting and diagnostic skills<\/li><li>Ability to work a&nbsp;<strong>7\/7 rotating schedule<\/strong><\/li><li>Commitment to safety and quality workmanship<\/li><li>Must be authorized to work in the U.S. without visa sponsorship<\/li><\/ul>\n<p><strong><strong>Preferred Qualifications<\/strong><\/strong><\/p>\n<ul><li>Experience working in mining or heavy industrial environments<\/li><li>ASE certifications or equivalent trade credentials<\/li><li>Ability to work independently in a fast-paced site environment<\/li><\/ul>\n<p><strong><strong>What Turner Staffing Group Offers<\/strong><\/strong><\/p>\n<ul><li>Opportunity to support a high-priority project with immediate impact<\/li><li>Work with a respected staffing partner supporting critical mining operations<\/li><li>Exposure to project-based roles with potential for future assignments<\/li><\/ul>\n<p><strong><strong>Apply Now<\/strong><\/strong><\/p>\n<p>If you are a skilled light vehicle mechanic ready to take on a short-term, high-impact project, we encourage you to apply.<\/p>\n<p><strong>Turner Staffing Group is an equal opportunity employer.<\/strong><\/p>","post_title":"Light Vehicle Mechanic","post_link":"https:\/\/turnerstaffing.com\/position\/light-vehicle-mechanic-3\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"","%location_country%":"United States","%location_city%":"Clayton","%location_state_id%":"ID","%location_state_name%":"Idaho","%location_city_state%":"Clayton, ID","%education%":"","%department%":"","%description%":"<p>Turner Staffing Group is seeking two to four<strong>&nbsp;Light Vehicle Mechanics<\/strong>&nbsp;to support a high-priority maintenance project for one of our&nbsp;<strong>mining industry clients<\/strong>&nbsp;in the&nbsp;<strong>Clayton, Idaho<\/strong>&nbsp;area. These are&nbsp;<strong>on-site, project-based&nbsp;<\/strong><strong>(3-6 month)&nbsp;<\/strong><strong>roles with a rotating schedule and competitive pay, ideal for mechanics&nbsp;<\/strong>ready to step into immediate, impactful work.<\/p>\n<p><strong><strong>Role Overview<\/strong><\/strong><\/p>\n<p>As a Light Vehicle Mechanic, you will support site operations by maintaining and repairing light-duty vehicles and mobile equipment used in an active mining environment. Safety, reliability, and rapid turnaround are critical to this role.<\/p>\n<p><strong><strong>Key Responsibilities<\/strong><\/strong><\/p>\n<ul><li>Diagnose, service, and repair, and maintain light-duty vehicles and site fleet equipment<\/li><li>Perform preventive maintenance and inspections<\/li><li>Troubleshoot mechanical, electrical, and hydraulic systems<\/li><li>Document repairs and maintenance activities accurately<\/li><li>Ensure all work is performed in compliance with safety standards and procedures<\/li><li>Support site operations by responding to urgent maintenance needs<\/li><\/ul>\n<p><strong><strong>Required Qualifications<\/strong><\/strong><\/p>\n<ul><li>Proven experience as a&nbsp;<strong>Light Vehicle Mechanic<\/strong>&nbsp;(mining or industrial experience preferred)<\/li><li>Strong troubleshooting and diagnostic skills<\/li><li>Ability to work a&nbsp;<strong>7\/7 rotating schedule<\/strong><\/li><li>Commitment to safety and quality workmanship<\/li><li>Must be authorized to work in the U.S. without visa sponsorship<\/li><\/ul>\n<p><strong><strong>Preferred Qualifications<\/strong><\/strong><\/p>\n<ul><li>Experience working in mining or heavy industrial environments<\/li><li>ASE certifications or equivalent trade credentials<\/li><li>Ability to work independently in a fast-paced site environment<\/li><\/ul>\n<p><strong><strong>What Turner Staffing Group Offers<\/strong><\/strong><\/p>\n<ul><li>Opportunity to support a high-priority project with immediate impact<\/li><li>Work with a respected staffing partner supporting critical mining operations<\/li><li>Exposure to project-based roles with potential for future assignments<\/li><\/ul>\n<p><strong><strong>Apply Now<\/strong><\/strong><\/p>\n<p>If you are a skilled light vehicle mechanic ready to take on a short-term, high-impact project, we encourage you to apply.<\/p>\n<p><strong>Turner Staffing Group is an equal opportunity employer.<\/strong><\/p>","%category%":"","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/4e172cfd6ede-light-vehicle-mechanic","%breezy_id%":"4e172cfd6ede","%breezy_friendly_id%":"4e172cfd6ede-light-vehicle-mechanic","%breezy_created_date%":"2026-01-12T15:11:09.077Z","%breezy_updated_date%":"2026-01-12T15:11:33.696Z","%_wpgmp_location_city%":"Clayton","%_wpgmp_location_state%":"ID","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Clayton, ID, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"44.2592165","%_wpgmp_metabox_longitude%":"-114.4011538","%rank_math_internal_links_processed%":"1"}},"id":3034,"infowindow_disable":false},{"source":"post","title":"Business Technologies Engineer","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Business Technologies Engineer\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    REQUIRED KNOWLEDGE SKILLS AND ABILITIES Strong understanding of technical processes and how they can address the process business needs Desire&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/business-technologies-engineer\/\" name=\"Business Technologies Engineer\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"REQUIRED KNOWLEDGE SKILLS AND ABILITIES Strong understanding of technical processes and how they can address the process business needs Desire&hellip;","address":"Kearny, AZ, USA","location":{"lat":"33.0613504","city":"Kearny","state":"AZ","country":"United States","lng":"-110.9066589","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/business-technologies-engineer\/","zoom":19,"extra_fields":{"post_excerpt":"REQUIRED KNOWLEDGE SKILLS AND ABILITIES Strong understanding of technical processes and how they can address the process business needs Desire&hellip;","post_content":"<p><strong>REQUIRED KNOWLEDGE SKILLS AND ABILITIES<\/strong><\/p>\n<p><\/p>\n<ul><li>Strong understanding of technical processes and how they can address the process business needs<\/li><li>Desire to work with multi-functional teams in a multi-national organization<\/li><li>Highly Motivated, Proactive Self-starter, with a passion for technology solutions in the process environment.<\/li><li>Ability to work both independently and as a part of a team in a fast-paced production focused environment<\/li><li>Ability to identify opportunities in new technologies, trends, and changes in the information management and research field<\/li><li>Excellent communication skills (the ability to listen to, explain to and influence Stakeholders) and the ability to partner with critical business \/ infrastructure and ability to clearly formulate positions on issues and articulate solutions<\/li><li>Able to perform analytical assessment of datasets and information flows across an extensive range of process business types and systems<\/li><li>Methodical with an analytical approach, paying close attention to detail<\/li><li>Highly organized and efficient with the ability to work well under pressure and meet challenging deadlines.<\/li><li>Ability to manage time effectively and set priorities.<\/li><li>Ability to think under stressful and adverse conditions<\/li><\/ul>","post_title":"Business Technologies Engineer","post_link":"https:\/\/turnerstaffing.com\/position\/business-technologies-engineer\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"","%location_country%":"United States","%location_city%":"Kearny","%location_state_id%":"AZ","%location_state_name%":"Arizona","%location_city_state%":"Kearny, AZ","%education%":"","%department%":"","%description%":"<p><strong>REQUIRED KNOWLEDGE SKILLS AND ABILITIES<\/strong><\/p>\n<p><\/p>\n<ul><li>Strong understanding of technical processes and how they can address the process business needs<\/li><li>Desire to work with multi-functional teams in a multi-national organization<\/li><li>Highly Motivated, Proactive Self-starter, with a passion for technology solutions in the process environment.<\/li><li>Ability to work both independently and as a part of a team in a fast-paced production focused environment<\/li><li>Ability to identify opportunities in new technologies, trends, and changes in the information management and research field<\/li><li>Excellent communication skills (the ability to listen to, explain to and influence Stakeholders) and the ability to partner with critical business \/ infrastructure and ability to clearly formulate positions on issues and articulate solutions<\/li><li>Able to perform analytical assessment of datasets and information flows across an extensive range of process business types and systems<\/li><li>Methodical with an analytical approach, paying close attention to detail<\/li><li>Highly organized and efficient with the ability to work well under pressure and meet challenging deadlines.<\/li><li>Ability to manage time effectively and set priorities.<\/li><li>Ability to think under stressful and adverse conditions<\/li><\/ul>","%category%":"Operations","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/9651758ecfa6-business-technologies-engineer","%breezy_id%":"9651758ecfa6","%breezy_friendly_id%":"9651758ecfa6-business-technologies-engineer","%breezy_created_date%":"2026-01-12T21:06:53.480Z","%breezy_updated_date%":"2026-01-12T21:07:23.403Z","%_wpgmp_location_city%":"Kearny","%_wpgmp_location_state%":"AZ","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Kearny, AZ, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"33.0613504","%_wpgmp_metabox_longitude%":"-110.9066589","%rank_math_internal_links_processed%":"1"}},"id":3035,"infowindow_disable":false},{"source":"post","title":"Plant Manager","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Plant Manager\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Our client is&nbsp;seeking a Plant Manager to provide direct supervision and leadership to department staff, ensuring a safe work environment&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/plant-manager\/\" name=\"Plant Manager\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Our client is&nbsp;seeking a Plant Manager to provide direct supervision and leadership to department staff, ensuring a safe work environment&hellip;","address":"Rialto, CA, USA","location":{"lat":"34.1064001","city":"Rialto","state":"CA","country":"United States","lng":"-117.3703235","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/plant-manager\/","zoom":19,"extra_fields":{"post_excerpt":"Our client is&nbsp;seeking a Plant Manager to provide direct supervision and leadership to department staff, ensuring a safe work environment&hellip;","post_content":"<p>Our client is&nbsp;seeking a <strong>Plant Manager<\/strong> to provide direct supervision and leadership to department staff, ensuring a safe work environment while producing high-quality products efficiently. This role requires strong operational management skills, a commitment to safety, and the ability to foster collaboration across departments.<\/p>\n<h4><strong>Key Responsibilities<\/strong><\/h4>\n<ul>\n<li>Maintain a safe working environment and enforce safety practices in all plant operations.<\/li>\n<li>Direct and manage day-to-day operations of the Concrete Precast Manufacturing Plant.<\/li>\n<li>Develop and implement plans to improve performance and reduce operating costs.<\/li>\n<li>Provide mentorship and performance feedback to team members.<\/li>\n<li>Collaborate with other departments to achieve production objectives.<\/li>\n<li>Track inventories and develop production plans.<\/li>\n<li>Troubleshoot production and resource issues.<\/li>\n<li>Write and maintain Standard Operating Procedures (SOPs) and monitor KPIs.<\/li>\n<li>Manage daily and weekly planning schedules, timekeeping, and headcount.<\/li>\n<li>Plan and budget plant operations.<\/li>\n<li>Coordinate with Maintenance Department for equipment repair and preventative maintenance.<\/li>\n<li>Ensure quality processes are in place to deliver superior products to customers.<\/li>\n<li>Conduct daily toolbox meetings and review safety topics.<\/li>\n<li>Support and maintain 5S work areas and housekeeping standards.<\/li>\n<\/ul>\n<h4><strong>Education &amp; Experience<\/strong><\/h4>\n<ul>\n<li>High school diploma or GED required.<\/li>\n<li>Minimum of 5 years of supervisory experience in a manufacturing or construction environment.<\/li>\n<li>Proficiency in English; Spanish preferred but not required.<\/li>\n<li>Strong knowledge of tools, equipment, materials, and techniques used in production and maintenance.<\/li>\n<li>Familiarity with record-keeping, scheduling, and safety procedures.<\/li>\n<\/ul>\n<h4><strong>Skills &amp; Competencies<\/strong><\/h4>\n<ul>\n<li>Leadership and team-building skills.<\/li>\n<li>Ability to work under pressure and manage multiple priorities.<\/li>\n<li>Strong problem-solving and troubleshooting abilities.<\/li>\n<li>Excellent communication and interpersonal skills.<\/li>\n<li>Commitment to safety and quality standards.<\/li><\/ul><p>Role is based out their Rialto, California location.<\/p>","post_title":"Plant Manager","post_link":"https:\/\/turnerstaffing.com\/position\/plant-manager\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Mid Level","%location_country%":"United States","%location_city%":"Rialto","%location_state_id%":"CA","%location_state_name%":"California","%location_city_state%":"Rialto, CA","%education%":"High School or Equivalent","%department%":"","%description%":"<p>Our client is&nbsp;seeking a <strong>Plant Manager<\/strong> to provide direct supervision and leadership to department staff, ensuring a safe work environment while producing high-quality products efficiently. This role requires strong operational management skills, a commitment to safety, and the ability to foster collaboration across departments.<\/p>\n<h4><strong>Key Responsibilities<\/strong><\/h4>\n<ul>\n<li>Maintain a safe working environment and enforce safety practices in all plant operations.<\/li>\n<li>Direct and manage day-to-day operations of the Concrete Precast Manufacturing Plant.<\/li>\n<li>Develop and implement plans to improve performance and reduce operating costs.<\/li>\n<li>Provide mentorship and performance feedback to team members.<\/li>\n<li>Collaborate with other departments to achieve production objectives.<\/li>\n<li>Track inventories and develop production plans.<\/li>\n<li>Troubleshoot production and resource issues.<\/li>\n<li>Write and maintain Standard Operating Procedures (SOPs) and monitor KPIs.<\/li>\n<li>Manage daily and weekly planning schedules, timekeeping, and headcount.<\/li>\n<li>Plan and budget plant operations.<\/li>\n<li>Coordinate with Maintenance Department for equipment repair and preventative maintenance.<\/li>\n<li>Ensure quality processes are in place to deliver superior products to customers.<\/li>\n<li>Conduct daily toolbox meetings and review safety topics.<\/li>\n<li>Support and maintain 5S work areas and housekeeping standards.<\/li>\n<\/ul>\n<h4><strong>Education &amp; Experience<\/strong><\/h4>\n<ul>\n<li>High school diploma or GED required.<\/li>\n<li>Minimum of 5 years of supervisory experience in a manufacturing or construction environment.<\/li>\n<li>Proficiency in English; Spanish preferred but not required.<\/li>\n<li>Strong knowledge of tools, equipment, materials, and techniques used in production and maintenance.<\/li>\n<li>Familiarity with record-keeping, scheduling, and safety procedures.<\/li>\n<\/ul>\n<h4><strong>Skills &amp; Competencies<\/strong><\/h4>\n<ul>\n<li>Leadership and team-building skills.<\/li>\n<li>Ability to work under pressure and manage multiple priorities.<\/li>\n<li>Strong problem-solving and troubleshooting abilities.<\/li>\n<li>Excellent communication and interpersonal skills.<\/li>\n<li>Commitment to safety and quality standards.<\/li><\/ul><p>Role is based out their Rialto, California location.<\/p>","%category%":"Other","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/a45e64b4cf36-plant-manager","%breezy_id%":"a45e64b4cf36","%breezy_friendly_id%":"a45e64b4cf36-plant-manager","%breezy_created_date%":"2026-01-09T23:10:24.347Z","%breezy_updated_date%":"2026-01-09T23:14:46.146Z","%_wpgmp_location_city%":"Rialto","%_wpgmp_location_state%":"CA","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Rialto, CA, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"34.1064001","%_wpgmp_metabox_longitude%":"-117.3703235","%rank_math_internal_links_processed%":"1"}},"id":3033,"infowindow_disable":false},{"source":"post","title":"General Foreman- Conveyor Belt","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    General Foreman- Conveyor Belt\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Our client is looking for an experienced General Foreman to lead conveyor belt service crews and manage multi-site projects. This&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/general-foreman-conveyor-belt\/\" name=\"General Foreman- Conveyor Belt\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Our client is looking for an experienced General Foreman to lead conveyor belt service crews and manage multi-site projects. 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\/general-foreman-conveyor-belt\/","zoom":19,"extra_fields":{"post_excerpt":"Our client is looking for an experienced General Foreman to lead conveyor belt service crews and manage multi-site projects. This&hellip;","post_content":"<p>Our client is looking for an experienced <strong>General Foreman<\/strong> to lead conveyor belt service crews and manage multi-site projects. This role ensures safe, efficient installation, maintenance, and repair of conveyor systems while fostering a strong team environment.<\/p>\n<h3><strong>Key Responsibilities<\/strong><\/h3>\n<ul>\n<li>Supervise and coordinate conveyor belt service crews.<\/li>\n<li>Oversee installation, splicing, vulcanizing, and maintenance of conveyor systems.<\/li>\n<li>Ensure compliance with OSHA, MSHA, and DOT regulations.<\/li>\n<li>Conduct site inspections, job walks, and provide accurate quotes.<\/li>\n<li>Promote safety culture through training and toolbox talks.<\/li>\n<li>Troubleshoot mechanical issues and maintain accurate documentation.<\/li>\n<li>Collaborate with project managers and clients to meet deadlines.<\/li>\n<\/ul>\n<h3><strong>Qualifications<\/strong><\/h3>\n<ul>\n<li>5+ years in conveyor belt splicing service, 3+ years in a supervisory role and setting up jobs and performing vulcanizing work<\/li>\n<li>Strong mechanical aptitude and leadership skills.<\/li>\n<li>Knowledge of safety standards and regulatory compliance.<\/li>\n<li>Ability to read technical drawings and blueprints.<\/li>\n<li>Valid driver\u2019s license; willingness to travel.<\/li>\n<\/ul>\n<h3>Role will be based out of Elko,&nbsp;NV.<\/h3>\n<ul>\n<\/ul>\n<p><\/p>","post_title":"General Foreman- Conveyor Belt","post_link":"https:\/\/turnerstaffing.com\/position\/general-foreman-conveyor-belt\/","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%":"High School or Equivalent","%department%":"","%description%":"<p>Our client is looking for an experienced <strong>General Foreman<\/strong> to lead conveyor belt service crews and manage multi-site projects. This role ensures safe, efficient installation, maintenance, and repair of conveyor systems while fostering a strong team environment.<\/p>\n<h3><strong>Key Responsibilities<\/strong><\/h3>\n<ul>\n<li>Supervise and coordinate conveyor belt service crews.<\/li>\n<li>Oversee installation, splicing, vulcanizing, and maintenance of conveyor systems.<\/li>\n<li>Ensure compliance with OSHA, MSHA, and DOT regulations.<\/li>\n<li>Conduct site inspections, job walks, and provide accurate quotes.<\/li>\n<li>Promote safety culture through training and toolbox talks.<\/li>\n<li>Troubleshoot mechanical issues and maintain accurate documentation.<\/li>\n<li>Collaborate with project managers and clients to meet deadlines.<\/li>\n<\/ul>\n<h3><strong>Qualifications<\/strong><\/h3>\n<ul>\n<li>5+ years in conveyor belt splicing service, 3+ years in a supervisory role and setting up jobs and performing vulcanizing work<\/li>\n<li>Strong mechanical aptitude and leadership skills.<\/li>\n<li>Knowledge of safety standards and regulatory compliance.<\/li>\n<li>Ability to read technical drawings and blueprints.<\/li>\n<li>Valid driver\u2019s license; willingness to travel.<\/li>\n<\/ul>\n<h3>Role will be based out of Elko,&nbsp;NV.<\/h3>\n<ul>\n<\/ul>\n<p><\/p>","%category%":"Other","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/3c6f70058f2b-general-foreman-conveyor-belt","%breezy_id%":"3c6f70058f2b","%breezy_friendly_id%":"3c6f70058f2b-general-foreman-conveyor-belt","%breezy_created_date%":"2026-01-08T18:41:42.257Z","%breezy_updated_date%":"2026-01-08T18:51:06.588Z","%_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":3031,"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 searching for a&nbsp;Project Engineer who will be&nbsp;responsible for the end\u2011to\u2011end technical and project execution of customer projects&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":"Our client is searching for a&nbsp;Project Engineer who will be&nbsp;responsible for the end\u2011to\u2011end technical and project execution of customer projects&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\/project-engineer\/","zoom":19,"extra_fields":{"post_excerpt":"Our client is searching for a&nbsp;Project Engineer who will be&nbsp;responsible for the end\u2011to\u2011end technical and project execution of customer projects&hellip;","post_content":"<p>Our client is searching for a&nbsp;Project Engineer who will be&nbsp;responsible for the end\u2011to\u2011end technical and project execution of customer projects \u2014 from design and planning through fabrication, delivery, and closeout. This role blends engineering expertise with project leadership to ensure all projects are delivered efficiently, on time, within budget, and in full compliance with quality and contractual requirements.<\/p>\n<p>Acting as both the technical authority and primary customer interface, the Project Engineer coordinates cross\u2011functional teams and oversees the integration of engineering, production, quality, and scheduling activities throughout the project lifecycle.<\/p>\n<p>Key Responsibilities<\/p><p>&nbsp;Customer &amp; Contract Management<\/p>\n\n\n\n<ul><li>Serve as the primary point of contact for our client's customers throughout the project.<\/li><li>Review and interpret contracts, specifications, and change orders to ensure technical and commercial alignment.<\/li><li>Lead commercial discussions \u2014 including billing, delivery schedules, and change requests \u2014 in partnership with Sales and Finance.<\/li><li>Represent the company professionally and ensure customer expectations are clearly managed and met.<\/li><\/ul><p>Technical Design &amp; Execution<\/p>\n\n\n\n\n<ul><li>Translate customer requirements into accurate, compliant design solutions.<\/li><li>Develop or oversee detailed designs using AutoCAD and related software, ensuring compliance with performance, quality, and regulatory standards.<\/li><li>Perform efficient design of pipe, fittings, reinforcement, and thrust restraint for water transmission projects.<\/li><li>Ensure all design deliverables are completed on schedule and receive necessary approvals.<\/li><li>Maintain accuracy, version control, and documentation integrity for all design outputs.<\/li><\/ul>\n<p>Cross\u2011Functional Coordination<\/p>\n\n\n\n<ul><li>Collaborate with Production, Quality, and Scheduling to maintain project alignment.<\/li><li>Secure timely approvals of drawings, submittals, and engineering documents.<\/li><li>Clearly communicate design updates, production requirements, and changes to all stakeholders.<\/li><li>Lead internal coordination meetings to track progress and resolve interface issues.<\/li><\/ul>\n<p><br>&nbsp;Project Planning, Monitoring &amp; Reporting<\/p>\n\n\n\n<ul><li>Develop and maintain thorough understanding of project schedules in coordination with the Scheduling team.<\/li><li>Monitor fabrication, inspection, and delivery milestones; proactively identify and escalate risks or delays.<\/li><li>Provide weekly progress updates to management and customers, including key accomplishments, risks, and mitigation plans.<\/li><li>Use project dashboards or reporting tools to maintain visibility across teams.<\/li><\/ul>\n<p><br>Financial &amp; Commercial Oversight<\/p>\n\n<ul><li>Ensure invoicing aligns with project progress and contractual milestones.<\/li><li>Manage scope changes, change orders, and variation requests in collaboration with operations teams.<\/li><\/ul>\n<p>&nbsp;Problem Solving &amp; Issue Resolution<\/p>\n\n\n<ul><li>Identify and resolve cross\u2011functional issues such as design conflicts, material delays, or quality deviations.<\/li><li>Lead root\u2011cause analyses for recurring technical or process issues.<\/li><li>Escalate critical risks with clear recommendations for mitigation.<\/li><\/ul>\n<p>Production Support &amp; Handoff<\/p>\n<p>Ensure all released designs are complete, accurate, and production\u2011ready.<\/p>\n<p>Work closely with operations teams to clarify technical details and support efficient production flow.<\/p>\n<p>Integrate field, production, and customer feedback to drive continuous improvement in future designs.<\/p>\n<p>Project Closeout<\/p>\n\n\n<ul><li>Confirm all deliverables \u2014 materials, documentation, as\u2011builts, certifications \u2014 meet contract requirements.<\/li><li>Conduct internal project closeout reviews to capture lessons learned.<\/li><li>Support final invoicing, warranty documentation, and resolution of any open items..<\/li><\/ul>\n\n\n\n<p>Requirements<\/p>\n\n\n<ul><li>Bachelor\u2019s degree in Engineering<\/li><li>5\u20138 years of combined experience in engineering design and project management in manufacturing, industrial, or construction environments.<\/li><li>Proven experience leading cross\u2011functional technical projects with direct customer interaction.<\/li><li>Proficiency with AutoCAD and project management tools (e.g., MS Project, Smartsheet).<\/li><li>Strong understanding of contract administration, project controls, and cost tracking.<\/li><\/ul>\n\n\n<p><br><\/p>\n\n\n\n\n\n\n<p><\/p>","post_title":"Project Engineer","post_link":"https:\/\/turnerstaffing.com\/position\/project-engineer\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Mid Level","%location_country%":"United States","%location_city%":"Dallas","%location_state_id%":"TX","%location_state_name%":"Texas","%location_city_state%":"Dallas, TX","%education%":"Bachelor's Degree","%department%":"","%description%":"<p>Our client is searching for a&nbsp;Project Engineer who will be&nbsp;responsible for the end\u2011to\u2011end technical and project execution of customer projects \u2014 from design and planning through fabrication, delivery, and closeout. This role blends engineering expertise with project leadership to ensure all projects are delivered efficiently, on time, within budget, and in full compliance with quality and contractual requirements.<\/p>\n<p>Acting as both the technical authority and primary customer interface, the Project Engineer coordinates cross\u2011functional teams and oversees the integration of engineering, production, quality, and scheduling activities throughout the project lifecycle.<\/p>\n<p>Key Responsibilities<\/p><p>&nbsp;Customer &amp; Contract Management<\/p>\n\n\n\n<ul><li>Serve as the primary point of contact for our client's customers throughout the project.<\/li><li>Review and interpret contracts, specifications, and change orders to ensure technical and commercial alignment.<\/li><li>Lead commercial discussions \u2014 including billing, delivery schedules, and change requests \u2014 in partnership with Sales and Finance.<\/li><li>Represent the company professionally and ensure customer expectations are clearly managed and met.<\/li><\/ul><p>Technical Design &amp; Execution<\/p>\n\n\n\n\n<ul><li>Translate customer requirements into accurate, compliant design solutions.<\/li><li>Develop or oversee detailed designs using AutoCAD and related software, ensuring compliance with performance, quality, and regulatory standards.<\/li><li>Perform efficient design of pipe, fittings, reinforcement, and thrust restraint for water transmission projects.<\/li><li>Ensure all design deliverables are completed on schedule and receive necessary approvals.<\/li><li>Maintain accuracy, version control, and documentation integrity for all design outputs.<\/li><\/ul>\n<p>Cross\u2011Functional Coordination<\/p>\n\n\n\n<ul><li>Collaborate with Production, Quality, and Scheduling to maintain project alignment.<\/li><li>Secure timely approvals of drawings, submittals, and engineering documents.<\/li><li>Clearly communicate design updates, production requirements, and changes to all stakeholders.<\/li><li>Lead internal coordination meetings to track progress and resolve interface issues.<\/li><\/ul>\n<p><br>&nbsp;Project Planning, Monitoring &amp; Reporting<\/p>\n\n\n\n<ul><li>Develop and maintain thorough understanding of project schedules in coordination with the Scheduling team.<\/li><li>Monitor fabrication, inspection, and delivery milestones; proactively identify and escalate risks or delays.<\/li><li>Provide weekly progress updates to management and customers, including key accomplishments, risks, and mitigation plans.<\/li><li>Use project dashboards or reporting tools to maintain visibility across teams.<\/li><\/ul>\n<p><br>Financial &amp; Commercial Oversight<\/p>\n\n<ul><li>Ensure invoicing aligns with project progress and contractual milestones.<\/li><li>Manage scope changes, change orders, and variation requests in collaboration with operations teams.<\/li><\/ul>\n<p>&nbsp;Problem Solving &amp; Issue Resolution<\/p>\n\n\n<ul><li>Identify and resolve cross\u2011functional issues such as design conflicts, material delays, or quality deviations.<\/li><li>Lead root\u2011cause analyses for recurring technical or process issues.<\/li><li>Escalate critical risks with clear recommendations for mitigation.<\/li><\/ul>\n<p>Production Support &amp; Handoff<\/p>\n<p>Ensure all released designs are complete, accurate, and production\u2011ready.<\/p>\n<p>Work closely with operations teams to clarify technical details and support efficient production flow.<\/p>\n<p>Integrate field, production, and customer feedback to drive continuous improvement in future designs.<\/p>\n<p>Project Closeout<\/p>\n\n\n<ul><li>Confirm all deliverables \u2014 materials, documentation, as\u2011builts, certifications \u2014 meet contract requirements.<\/li><li>Conduct internal project closeout reviews to capture lessons learned.<\/li><li>Support final invoicing, warranty documentation, and resolution of any open items..<\/li><\/ul>\n\n\n\n<p>Requirements<\/p>\n\n\n<ul><li>Bachelor\u2019s degree in Engineering<\/li><li>5\u20138 years of combined experience in engineering design and project management in manufacturing, industrial, or construction environments.<\/li><li>Proven experience leading cross\u2011functional technical projects with direct customer interaction.<\/li><li>Proficiency with AutoCAD and project management tools (e.g., MS Project, Smartsheet).<\/li><li>Strong understanding of contract administration, project controls, and cost tracking.<\/li><\/ul>\n\n\n<p><br><\/p>\n\n\n\n\n\n\n<p><\/p>","%category%":"Other","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/99c7713b82f1-project-engineer","%breezy_id%":"99c7713b82f1","%breezy_friendly_id%":"99c7713b82f1-project-engineer","%breezy_created_date%":"2026-01-06T00:10:34.132Z","%breezy_updated_date%":"2026-01-06T00:15:40.136Z","%_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":3028,"infowindow_disable":false},{"source":"post","title":"Design Manager","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Design Manager\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Our client is looking for a&nbsp;Design Manager in their Dallas, Texas location.&nbsp;&nbsp;This role will be&nbsp;responsible for leading the steel pipe&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/design-manager\/\" name=\"Design Manager\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Our client is looking for a&nbsp;Design Manager in their Dallas, Texas location.&nbsp;&nbsp;This role will be&nbsp;responsible for leading the steel pipe&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\/design-manager\/","zoom":19,"extra_fields":{"post_excerpt":"Our client is looking for a&nbsp;Design Manager in their Dallas, Texas location.&nbsp;&nbsp;This role will be&nbsp;responsible for leading the steel pipe&hellip;","post_content":"<p>Our client is looking for a&nbsp;<strong>Design Manager<\/strong> in their Dallas, Texas location.&nbsp;&nbsp;This role will be&nbsp;responsible for leading the steel pipe design function and managing a team of Project Engineers dedicated to steel pipe projects. This role provides technical leadership, design governance, workload planning, and project oversight, ensuring all engineering designs meet quality, safety, cost, and schedule requirements.<\/p>\n<p>The Design Manager serves as the technical authority for pipe design, oversees design outputs across the project lifecycle, and ensures seamless integration between engineering, production, procurement, quality, and project management. They proactively support problem resolution, drive standardization, and mentor engineering staff to elevate technical competency and project delivery performance.<\/p>\n<h3><strong>Key Responsibilities<\/strong><\/h3>\n<p><strong>Team Leadership &amp; Talent Development<\/strong><\/p>\n<ul>\n<li>Lead and manage a team of Project Engineers focused on steel pipe and fittings design, layout, and project execution.<\/li>\n<li>Conduct regular interaction with team members, provide workload planning, and allocate resources across active and upcoming projects<\/li>\n<\/ul>\n<p><strong>Technical Ownership of Steel Design<\/strong><\/p>\n<ul>\n<li>Oversee all steel pipe and fittings design activities, ensuring accuracy, compliance, and alignment with project-specific requirements, national standards, and internal guidelines.<\/li>\n<li>Review and approve engineering drawings, design packages, and technical documentation produced by Project Engineers.<\/li>\n<li>Serve as the internal expert for steel engineering queries, calculations, and design decisions.<\/li>\n<\/ul>\n<p><strong>Cross-Functional Coordination<\/strong><\/p>\n<ul>\n<li>Act as the technical liaison between Engineering, Production, Quality, Scheduling, Operations, and Procurement for all steel projects to ensure on-time delivery of designs and final products.<\/li>\n<li>Ensure timely release of designs and submittals to support production schedules and customer approvals.<\/li>\n<li>Drive alignment on technical requirements, risk mitigation actions, and design impacts across functions.<\/li>\n<\/ul>\n<p><strong>Project Oversight &amp; Delivery Support<\/strong><\/p>\n<ul>\n<li>Oversee the technical design aspects of multiple steel projects from kickoff to closeout.<\/li>\n<li>Ensure Project Engineers deliver designs and engineering documents on schedule and within scope.<\/li>\n<li>Monitor fabrication, inspection, and delivery to ensure all project milestones are met; provide support to proactively flag risks and resolve issues.<\/li>\n<li>Support fabrication, installation, and commissioning activities by providing technical guidance and resolving escalations.<\/li>\n<\/ul>\n<p><strong>Quality, Compliance &amp; Process Governance<\/strong><\/p>\n<ul>\n<li>Ensure all engineering work complies with relevant codes, standards, and internal quality policies.<\/li>\n<li>Coordinate with Quality to support inspections and nonconformance resolution.<\/li>\n<li>Establish design review checkpoints and lead multidisciplinary technical reviews.<\/li>\n<li>Implement corrective actions and capture lessons learned for continuous improvement.<\/li>\n<\/ul>\n<p><strong>Technical Strategy &amp; Continuous Improvement<\/strong><\/p>\n<ul>\n<li>Identify and implement improvements in design workflows, tools, and engineering processes.<\/li>\n<li>Champion standardization across steel fittings designs to enhance quality and reduce cycle time.<\/li>\n<\/ul>\n<h3><strong>Education &amp; Experience Requirements<\/strong><\/h3>\n<ul>\n<li>Bachelor\u2019s degree in Civil Engineering, Mechanical Engineering, Structural Engineering, or related field.<\/li>\n<li>7\u201310 years of experience in pipeline engineering, steel design, structural engineering, or steel fabrication projects.<\/li>\n<li>3+ years of leadership, supervisory, or team lead experience (preferred).<\/li>\n<li>Strong experience with AutoCAD, design tools, engineering calculations, and manufacturing processes.<\/li>\n<li>Proven track record in delivering engineering packages for industrial, structural steel, or fabrication projects.<\/li>\n<li>Experience working cross-functionally with production, quality, scheduling, and project teams.<\/li>\n<li>Professional licensure or ability to obtain licensure is required.<\/li><\/ul>","post_title":"Design Manager","post_link":"https:\/\/turnerstaffing.com\/position\/design-manager\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Mid Level","%location_country%":"United States","%location_city%":"Dallas","%location_state_id%":"TX","%location_state_name%":"Texas","%location_city_state%":"Dallas, TX","%education%":"Bachelor's Degree","%department%":"","%description%":"<p>Our client is looking for a&nbsp;<strong>Design Manager<\/strong> in their Dallas, Texas location.&nbsp;&nbsp;This role will be&nbsp;responsible for leading the steel pipe design function and managing a team of Project Engineers dedicated to steel pipe projects. This role provides technical leadership, design governance, workload planning, and project oversight, ensuring all engineering designs meet quality, safety, cost, and schedule requirements.<\/p>\n<p>The Design Manager serves as the technical authority for pipe design, oversees design outputs across the project lifecycle, and ensures seamless integration between engineering, production, procurement, quality, and project management. They proactively support problem resolution, drive standardization, and mentor engineering staff to elevate technical competency and project delivery performance.<\/p>\n<h3><strong>Key Responsibilities<\/strong><\/h3>\n<p><strong>Team Leadership &amp; Talent Development<\/strong><\/p>\n<ul>\n<li>Lead and manage a team of Project Engineers focused on steel pipe and fittings design, layout, and project execution.<\/li>\n<li>Conduct regular interaction with team members, provide workload planning, and allocate resources across active and upcoming projects<\/li>\n<\/ul>\n<p><strong>Technical Ownership of Steel Design<\/strong><\/p>\n<ul>\n<li>Oversee all steel pipe and fittings design activities, ensuring accuracy, compliance, and alignment with project-specific requirements, national standards, and internal guidelines.<\/li>\n<li>Review and approve engineering drawings, design packages, and technical documentation produced by Project Engineers.<\/li>\n<li>Serve as the internal expert for steel engineering queries, calculations, and design decisions.<\/li>\n<\/ul>\n<p><strong>Cross-Functional Coordination<\/strong><\/p>\n<ul>\n<li>Act as the technical liaison between Engineering, Production, Quality, Scheduling, Operations, and Procurement for all steel projects to ensure on-time delivery of designs and final products.<\/li>\n<li>Ensure timely release of designs and submittals to support production schedules and customer approvals.<\/li>\n<li>Drive alignment on technical requirements, risk mitigation actions, and design impacts across functions.<\/li>\n<\/ul>\n<p><strong>Project Oversight &amp; Delivery Support<\/strong><\/p>\n<ul>\n<li>Oversee the technical design aspects of multiple steel projects from kickoff to closeout.<\/li>\n<li>Ensure Project Engineers deliver designs and engineering documents on schedule and within scope.<\/li>\n<li>Monitor fabrication, inspection, and delivery to ensure all project milestones are met; provide support to proactively flag risks and resolve issues.<\/li>\n<li>Support fabrication, installation, and commissioning activities by providing technical guidance and resolving escalations.<\/li>\n<\/ul>\n<p><strong>Quality, Compliance &amp; Process Governance<\/strong><\/p>\n<ul>\n<li>Ensure all engineering work complies with relevant codes, standards, and internal quality policies.<\/li>\n<li>Coordinate with Quality to support inspections and nonconformance resolution.<\/li>\n<li>Establish design review checkpoints and lead multidisciplinary technical reviews.<\/li>\n<li>Implement corrective actions and capture lessons learned for continuous improvement.<\/li>\n<\/ul>\n<p><strong>Technical Strategy &amp; Continuous Improvement<\/strong><\/p>\n<ul>\n<li>Identify and implement improvements in design workflows, tools, and engineering processes.<\/li>\n<li>Champion standardization across steel fittings designs to enhance quality and reduce cycle time.<\/li>\n<\/ul>\n<h3><strong>Education &amp; Experience Requirements<\/strong><\/h3>\n<ul>\n<li>Bachelor\u2019s degree in Civil Engineering, Mechanical Engineering, Structural Engineering, or related field.<\/li>\n<li>7\u201310 years of experience in pipeline engineering, steel design, structural engineering, or steel fabrication projects.<\/li>\n<li>3+ years of leadership, supervisory, or team lead experience (preferred).<\/li>\n<li>Strong experience with AutoCAD, design tools, engineering calculations, and manufacturing processes.<\/li>\n<li>Proven track record in delivering engineering packages for industrial, structural steel, or fabrication projects.<\/li>\n<li>Experience working cross-functionally with production, quality, scheduling, and project teams.<\/li>\n<li>Professional licensure or ability to obtain licensure is required.<\/li><\/ul>","%category%":"Other","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/4b96348db5e8-design-manager","%breezy_id%":"4b96348db5e8","%breezy_friendly_id%":"4b96348db5e8-design-manager","%breezy_created_date%":"2026-01-06T17:50:08.976Z","%breezy_updated_date%":"2026-01-06T17:51:28.517Z","%_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":3029,"infowindow_disable":false},{"source":"post","title":"Mining Foreman","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Mining Foreman\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Turner Mining Group &#8211; Project Foreman&nbsp; Do you love mining? Do you think differently? Are you ready to define the&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/mining-foreman-3\/\" name=\"Mining Foreman\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Turner Mining Group &#8211; Project Foreman&nbsp; Do you love mining? Do you think differently? Are you ready to define the&hellip;","address":"Crane, TX, USA","location":{"lat":"31.3973624","city":"Crane","state":"TX","country":"United States","lng":"-102.3501419","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/mining-foreman-3\/","zoom":19,"extra_fields":{"post_excerpt":"Turner Mining Group &#8211; Project Foreman&nbsp; Do you love mining? Do you think differently? Are you ready to define the&hellip;","post_content":"<p><strong><u>Turner Mining Group - Project Foreman&nbsp;<\/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><strong>Essential Skills &amp; Knowledge:<\/strong><\/p>\n<ul><li>Assist in the management of heavy civil and\/or mining projects from inception to completion and has demonstrated experience in the industry <\/li><li>Assist in the execution of projects (ex. project work plans and proper documentation and records including scope of work, driving the schedule, etc.)<\/li><li>Support Project Superintendent in tracking of project progress <\/li><li>Lead onsite personnel to achieve project outcomes<\/li><li>Coordinate between maintenance, operations and external contractors<\/li><li>Ensure that company policies, standards and procedures are met<\/li><li>Manage physical construction of heavy civil and\/or mining projects<\/li><li>Ensure that all onsite safety policies, procedures, and protocols are practiced<\/li><li>Experienced with Operating Heavy Equipment, and have the ability to train, coach, and mentor onsite personnel<\/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":"Mining Foreman","post_link":"https:\/\/turnerstaffing.com\/position\/mining-foreman-3\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Associate","%location_country%":"United States","%location_city%":"Crane","%location_state_id%":"TX","%location_state_name%":"Texas","%location_city_state%":"Crane, TX","%education%":"Unspecified","%department%":"Operations","%description%":"<p><strong><u>Turner Mining Group - Project Foreman&nbsp;<\/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><strong>Essential Skills &amp; Knowledge:<\/strong><\/p>\n<ul><li>Assist in the management of heavy civil and\/or mining projects from inception to completion and has demonstrated experience in the industry <\/li><li>Assist in the execution of projects (ex. project work plans and proper documentation and records including scope of work, driving the schedule, etc.)<\/li><li>Support Project Superintendent in tracking of project progress <\/li><li>Lead onsite personnel to achieve project outcomes<\/li><li>Coordinate between maintenance, operations and external contractors<\/li><li>Ensure that company policies, standards and procedures are met<\/li><li>Manage physical construction of heavy civil and\/or mining projects<\/li><li>Ensure that all onsite safety policies, procedures, and protocols are practiced<\/li><li>Experienced with Operating Heavy Equipment, and have the ability to train, coach, and mentor onsite personnel<\/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%":"Operations","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/86c9003b3d96-mining-foreman","%breezy_id%":"86c9003b3d96","%breezy_friendly_id%":"86c9003b3d96-mining-foreman","%breezy_created_date%":"2024-11-21T14:57:06.651Z","%breezy_updated_date%":"2026-01-06T20:21:30.074Z","%_wpgmp_location_city%":"Crane","%_wpgmp_location_state%":"TX","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Crane, TX, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"31.3973624","%_wpgmp_metabox_longitude%":"-102.3501419","%rank_math_internal_links_processed%":"1"}},"id":3027,"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 for this onsite, project-based position will be responsible for the configuration, installation, and imaging of&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 for this onsite, project-based position will be responsible for the configuration, installation, and imaging 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\/it-service-desk-technician-2\/","zoom":19,"extra_fields":{"post_excerpt":"Position Description: The successful candidate for this onsite, project-based position will be responsible for the configuration, installation, and imaging of&hellip;","post_content":"<p><strong><span style=\"color:#2f5496\">Position Description:<\/span><\/strong><\/p><p><span style=\"color:#555555\">T<\/span><span style=\"color:#555555\">he successful candidate for this onsite, project-based position will be responsible for the configuration, installation, and imaging of personal computers; installation, configuration and support of desktop software systems on a periodic basis; perform other duties as assigned.<\/span><\/p><p><strong><span style=\"color:#2f5496\">Key Responsibilities:<\/span><\/strong><br \/><\/p><ul><li><span style=\"color:#555555\">Daily maintenance tasks, imaging computers and remediate broken clients<\/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\"><\/span>Exceptional customer service\/interpersonal skills required<\/li><li>Authorized to work in the US without work visa sponsorship<\/li><li>Must be located within 8 hours of Elk, NV<\/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%":"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;\">T<\/span><span style=\"color:#555555;\">he successful candidate for this onsite, project-based position will be responsible for the configuration, installation, and imaging of personal computers; installation, configuration and support of desktop software systems on a periodic basis; perform other duties as assigned.<\/span><\/p><p><strong><span style=\"color:#2f5496;\">Key Responsibilities:<\/span><\/strong><br \/><\/p><ul><li><span style=\"color:#555555;\">Daily maintenance tasks, imaging computers and remediate broken clients<\/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;\"><\/span>Exceptional customer service\/interpersonal skills required<\/li><li>Authorized to work in the US without work visa sponsorship<\/li><li>Must be located within 8 hours of Elk, NV<\/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\/mfe6hygjtydssj9n9zur1dmkjw","%crelate_id%":"mfe6hygjtydssj9n9zur1dmkjw","%crelate_created_date%":"2025-12-22T15:56:22.14Z","%crelate_updated_date%":"2026-02-04T13:39:37.59Z","%_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":3025,"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    Turner Staffing Group is seeking&nbsp;three IT Service Desk Technicians&nbsp;to support a large-scale technology initiative for one of our&nbsp;mining industry clients&nbsp;in&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":"Turner Staffing Group is seeking&nbsp;three IT Service Desk Technicians&nbsp;to support a large-scale technology initiative for one of our&nbsp;mining industry clients&nbsp;in&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\/","zoom":19,"extra_fields":{"post_excerpt":"Turner Staffing Group is seeking&nbsp;three IT Service Desk Technicians&nbsp;to support a large-scale technology initiative for one of our&nbsp;mining industry clients&nbsp;in&hellip;","post_content":"<p>Turner Staffing Group is seeking&nbsp;<strong>three IT Service Desk Technicians<\/strong>&nbsp;to support a large-scale technology initiative for one of our&nbsp;<strong>mining industry clients<\/strong>&nbsp;in the Elko, Nevada area. This is an&nbsp;<strong>on-site, project-based assignment<\/strong>&nbsp;expected to last approximately&nbsp;<strong>12 months<\/strong>, supporting end-user computing environments across active industrial operations.<\/p>\n<p>This role is ideal for hands-on IT professionals who enjoy hardware deployment, desktop support, and working directly with end users in a fast-paced operational environment.<\/p>\n<p><strong><strong>Position Summary<\/strong><\/strong><\/p>\n<p>The IT Service Desk Technician will be responsible for the&nbsp;<strong>configuration, installation, imaging, and support of personal computers and desktop software systems<\/strong>. The role focuses on daily maintenance activities, device remediation, and ensuring reliable end-user computing performance.<\/p>\n<p><strong><strong>Key Responsibilities<\/strong><\/strong><\/p>\n<ul><li>Configure, install, and image desktop and laptop computers<\/li><li>Perform daily maintenance tasks, including remediating broken or malfunctioning client devices<\/li><li>Install, configure, and support desktop software systems<\/li><li>Provide onsite technical support to end users<\/li><li>Maintain accurate documentation of work performed<\/li><li>Perform additional IT support duties as assigned<\/li><\/ul>\n<p><strong><strong>Required Qualifications<\/strong><\/strong><\/p>\n<ul><li><strong>Minimum of two (2) years of PC Technician experience<\/strong>&nbsp;in a business or enterprise networking environment<\/li><li>Strong working knowledge of desktop hardware, imaging, and troubleshooting<\/li><li><strong>Exceptional customer service and interpersonal skills<\/strong><\/li><li>Ability to lift and carry&nbsp;<strong>up to 50 pounds<\/strong><\/li><li>Must be located within&nbsp;<strong>8 hours of Elko, NV<\/strong><\/li><li>Must be authorized to work in the U.S. without visa sponsorship<\/li><\/ul>\n<p><strong><strong>Preferred Qualifications<\/strong><\/strong><\/p>\n<ul><li>Bachelor\u2019s degree in&nbsp;<strong>Computer Science<\/strong>&nbsp;or related field<\/li><li>Microsoft&nbsp;<strong>MCSA or MCSE<\/strong>&nbsp;certifications<\/li><li><strong>CompTIA A+<\/strong>&nbsp;certification<\/li><\/ul>\n<p><strong><strong>What Turner Staffing Group Offers<\/strong><\/strong><\/p>\n<ul><li>Competitive pay with&nbsp;<strong>per diem and mileage provided<\/strong><\/li><li>Great schedule: 4 x 10-hour days<\/li><li>Comprehensive benefits package<\/li><li>Opportunity to make a meaningful impact on a high-visibility project<\/li><li>Work in a collaborative, high-performing team environment<\/li><li>Exposure to large-scale IT deployments in an industrial setting<\/li><li>Opportunities to grow skills and work alongside experienced professionals<\/li><\/ul>\n<p><strong><strong>Apply Today<\/strong><\/strong><\/p>\n<p>If you are a hands-on IT professional who enjoys onsite support and project-based work in an operational environment, we encourage you to apply.<\/p>\n<p><strong>Turner Staffing Group is an equal opportunity employer.<\/strong><\/p>","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%":"Elko","%location_state_id%":"NV","%location_state_name%":"Nevada","%location_city_state%":"Elko, NV","%education%":"","%department%":"","%description%":"<p>Turner Staffing Group is seeking&nbsp;<strong>three IT Service Desk Technicians<\/strong>&nbsp;to support a large-scale technology initiative for one of our&nbsp;<strong>mining industry clients<\/strong>&nbsp;in the Elko, Nevada area. This is an&nbsp;<strong>on-site, project-based assignment<\/strong>&nbsp;expected to last approximately&nbsp;<strong>12 months<\/strong>, supporting end-user computing environments across active industrial operations.<\/p>\n<p>This role is ideal for hands-on IT professionals who enjoy hardware deployment, desktop support, and working directly with end users in a fast-paced operational environment.<\/p>\n<p><strong><strong>Position Summary<\/strong><\/strong><\/p>\n<p>The IT Service Desk Technician will be responsible for the&nbsp;<strong>configuration, installation, imaging, and support of personal computers and desktop software systems<\/strong>. The role focuses on daily maintenance activities, device remediation, and ensuring reliable end-user computing performance.<\/p>\n<p><strong><strong>Key Responsibilities<\/strong><\/strong><\/p>\n<ul><li>Configure, install, and image desktop and laptop computers<\/li><li>Perform daily maintenance tasks, including remediating broken or malfunctioning client devices<\/li><li>Install, configure, and support desktop software systems<\/li><li>Provide onsite technical support to end users<\/li><li>Maintain accurate documentation of work performed<\/li><li>Perform additional IT support duties as assigned<\/li><\/ul>\n<p><strong><strong>Required Qualifications<\/strong><\/strong><\/p>\n<ul><li><strong>Minimum of two (2) years of PC Technician experience<\/strong>&nbsp;in a business or enterprise networking environment<\/li><li>Strong working knowledge of desktop hardware, imaging, and troubleshooting<\/li><li><strong>Exceptional customer service and interpersonal skills<\/strong><\/li><li>Ability to lift and carry&nbsp;<strong>up to 50 pounds<\/strong><\/li><li>Must be located within&nbsp;<strong>8 hours of Elko, NV<\/strong><\/li><li>Must be authorized to work in the U.S. without visa sponsorship<\/li><\/ul>\n<p><strong><strong>Preferred Qualifications<\/strong><\/strong><\/p>\n<ul><li>Bachelor\u2019s degree in&nbsp;<strong>Computer Science<\/strong>&nbsp;or related field<\/li><li>Microsoft&nbsp;<strong>MCSA or MCSE<\/strong>&nbsp;certifications<\/li><li><strong>CompTIA A+<\/strong>&nbsp;certification<\/li><\/ul>\n<p><strong><strong>What Turner Staffing Group Offers<\/strong><\/strong><\/p>\n<ul><li>Competitive pay with&nbsp;<strong>per diem and mileage provided<\/strong><\/li><li>Great schedule: 4 x 10-hour days<\/li><li>Comprehensive benefits package<\/li><li>Opportunity to make a meaningful impact on a high-visibility project<\/li><li>Work in a collaborative, high-performing team environment<\/li><li>Exposure to large-scale IT deployments in an industrial setting<\/li><li>Opportunities to grow skills and work alongside experienced professionals<\/li><\/ul>\n<p><strong><strong>Apply Today<\/strong><\/strong><\/p>\n<p>If you are a hands-on IT professional who enjoys onsite support and project-based work in an operational environment, we encourage you to apply.<\/p>\n<p><strong>Turner Staffing Group is an equal opportunity employer.<\/strong><\/p>","%category%":"","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/2a3c138e6efe-it-service-desk-technician","%breezy_id%":"2a3c138e6efe","%breezy_friendly_id%":"2a3c138e6efe-it-service-desk-technician","%breezy_created_date%":"2026-01-05T18:40:43.684Z","%breezy_updated_date%":"2026-01-05T18:41:18.660Z","%_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":3021,"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    As a Light Vehicle Mechanic, you will be responsible for maintaining, diagnosing, and repairing light vehicles used in mining operations.&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/light-vehicle-mechanic-2\/\" name=\"Light Vehicle Mechanic\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"As a Light Vehicle Mechanic, you will be responsible for maintaining, diagnosing, and repairing light vehicles used in mining operations.&hellip;","address":"Challis, ID, USA","location":{"lat":"44.5046445","city":"Challis","state":"ID","country":"United States","lng":"-114.2317308","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/light-vehicle-mechanic-2\/","zoom":19,"extra_fields":{"post_excerpt":"As a Light Vehicle Mechanic, you will be responsible for maintaining, diagnosing, and repairing light vehicles used in mining operations.&hellip;","post_content":"<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>&nbsp;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>&nbsp;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>&nbsp;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>&nbsp;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>&nbsp;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>&nbsp;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>&nbsp;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-2\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Contract","%experience%":"Associate","%location_country%":"United States","%location_city%":"Challis","%location_state_id%":"ID","%location_state_name%":"Idaho","%location_city_state%":"Challis, ID","%education%":"High School or Equivalent","%department%":"","%description%":"<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>&nbsp;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>&nbsp;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>&nbsp;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>&nbsp;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>&nbsp;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>&nbsp;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>&nbsp;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\/b0e93636611d-light-vehicle-mechanic","%breezy_id%":"b0e93636611d","%breezy_friendly_id%":"b0e93636611d-light-vehicle-mechanic","%breezy_created_date%":"2026-01-05T21:11:19.930Z","%breezy_updated_date%":"2026-01-05T21:12:12.580Z","%_wpgmp_location_city%":"Challis","%_wpgmp_location_state%":"ID","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Challis, ID, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"44.5046445","%_wpgmp_metabox_longitude%":"-114.2317308","%rank_math_internal_links_processed%":"1"}},"id":3022,"infowindow_disable":false},{"source":"post","title":"Project Manager- Oil &amp; Gas","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Project Manager- Oil &amp; Gas\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Project Manager \u2013 Oil &amp; Gas Position Overview The Project Manager oversees all phases of oil and gas construction and&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/project-manager-oil-gas\/\" name=\"Project Manager- Oil &amp; Gas\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Project Manager \u2013 Oil &amp; Gas Position Overview The Project Manager oversees all phases of oil and gas construction and&hellip;","address":"Wyalusing, PA, USA","location":{"lat":"41.6681309","city":"Wyalusing","state":"PA","country":"United States","lng":"-76.2618786","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/project-manager-oil-gas\/","zoom":19,"extra_fields":{"post_excerpt":"Project Manager \u2013 Oil &amp; Gas Position Overview The Project Manager oversees all phases of oil and gas construction and&hellip;","post_content":"<h1><strong>Project Manager \u2013 Oil &amp; Gas<\/strong><\/h1>\n<p><strong>Position Overview<\/strong><br>\nThe Project Manager oversees all phases of oil and gas construction and facility projects, from initial planning through successful completion. This role directs and coordinates daily project activities, ensuring safe, efficient, and compliant execution. The Project Manager is responsible for communication among stakeholders, managing field operations, and maintaining alignment with project scope, schedule, and budget.<\/p>\n<h2><strong>Key Responsibilities<\/strong><\/h2>\n<ul>\n<li>Uphold company core values of <strong>accountability, adaptability, integrity, and teamwork<\/strong><\/li>\n<li>Lead project planning, scope definition, scheduling, and resource allocation for oil and gas construction or facility projects<\/li>\n<li>Manage project budgets, monitor job costing, and ensure overall project profitability<\/li>\n<li>Oversee procurement of materials, equipment, and services, ensuring timely delivery to job sites<\/li>\n<li>Direct and coordinate technicians, subcontractors, inspectors, and vendors to support safe and timely project execution<\/li>\n<li>Conduct and lead project meetings, providing stakeholders with updates on timelines, costs, risks, and operational progress<\/li>\n<li>Track project milestones, identify potential delays or issues, and implement corrective actions<\/li>\n<li>Perform routine field visits to verify progress, ensure compliance with safety and environmental standards, and uphold quality expectations<\/li>\n<li>Maintain accurate project documentation including permits, drawings, MOCs (Management of Change), change orders, daily reports, and regulatory records<\/li>\n<li>Ensure compliance with local, state, and federal regulations, including applicable oil and gas codes, safety standards, and industry best practices (e.g., OSHA, API, NFPA)<\/li>\n<\/ul>\n<h2><strong>Qualifications<\/strong><\/h2>\n<ul>\n<li>Valid driver\u2019s license<\/li>\n<li>Strong communication, leadership, and team\u2011coordination skills<\/li>\n<li>Minimum <strong>5 years of experience in the oil and gas or industrial construction industry<\/strong><\/li>\n<li>Proficiency in Microsoft Office and electronic communication platforms<\/li>\n<li>Strong analytical skills with exceptional attention to detail<\/li>\n<li>Ability to identify and resolve problems in dynamic, fast\u2011paced project environments<\/li>\n<li>Demonstrated ability to manage <strong>multiple complex projects simultaneously<\/strong> while maintaining organization and accuracy<\/li>\n<\/ul><p><\/p>","post_title":"Project Manager- Oil &amp; Gas","post_link":"https:\/\/turnerstaffing.com\/position\/project-manager-oil-gas\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Mid Level","%location_country%":"United States","%location_city%":"Wyalusing","%location_state_id%":"PA","%location_state_name%":"Pennsylvania","%location_city_state%":"Wyalusing, PA","%education%":"High School or Equivalent","%department%":"","%description%":"<h1><strong>Project Manager \u2013 Oil &amp; Gas<\/strong><\/h1>\n<p><strong>Position Overview<\/strong><br>\nThe Project Manager oversees all phases of oil and gas construction and facility projects, from initial planning through successful completion. This role directs and coordinates daily project activities, ensuring safe, efficient, and compliant execution. The Project Manager is responsible for communication among stakeholders, managing field operations, and maintaining alignment with project scope, schedule, and budget.<\/p>\n<h2><strong>Key Responsibilities<\/strong><\/h2>\n<ul>\n<li>Uphold company core values of <strong>accountability, adaptability, integrity, and teamwork<\/strong><\/li>\n<li>Lead project planning, scope definition, scheduling, and resource allocation for oil and gas construction or facility projects<\/li>\n<li>Manage project budgets, monitor job costing, and ensure overall project profitability<\/li>\n<li>Oversee procurement of materials, equipment, and services, ensuring timely delivery to job sites<\/li>\n<li>Direct and coordinate technicians, subcontractors, inspectors, and vendors to support safe and timely project execution<\/li>\n<li>Conduct and lead project meetings, providing stakeholders with updates on timelines, costs, risks, and operational progress<\/li>\n<li>Track project milestones, identify potential delays or issues, and implement corrective actions<\/li>\n<li>Perform routine field visits to verify progress, ensure compliance with safety and environmental standards, and uphold quality expectations<\/li>\n<li>Maintain accurate project documentation including permits, drawings, MOCs (Management of Change), change orders, daily reports, and regulatory records<\/li>\n<li>Ensure compliance with local, state, and federal regulations, including applicable oil and gas codes, safety standards, and industry best practices (e.g., OSHA, API, NFPA)<\/li>\n<\/ul>\n<h2><strong>Qualifications<\/strong><\/h2>\n<ul>\n<li>Valid driver\u2019s license<\/li>\n<li>Strong communication, leadership, and team\u2011coordination skills<\/li>\n<li>Minimum <strong>5 years of experience in the oil and gas or industrial construction industry<\/strong><\/li>\n<li>Proficiency in Microsoft Office and electronic communication platforms<\/li>\n<li>Strong analytical skills with exceptional attention to detail<\/li>\n<li>Ability to identify and resolve problems in dynamic, fast\u2011paced project environments<\/li>\n<li>Demonstrated ability to manage <strong>multiple complex projects simultaneously<\/strong> while maintaining organization and accuracy<\/li>\n<\/ul><p><\/p>","%category%":"Other","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/a4e2aa735f03-project-manager-oil-gas","%breezy_id%":"a4e2aa735f03","%breezy_friendly_id%":"a4e2aa735f03-project-manager-oil-gas","%breezy_created_date%":"2026-01-05T21:18:42.818Z","%breezy_updated_date%":"2026-01-05T21:26:08.184Z","%_wpgmp_location_city%":"Wyalusing","%_wpgmp_location_state%":"PA","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Wyalusing, PA, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"41.6681309","%_wpgmp_metabox_longitude%":"-76.2618786","%rank_math_internal_links_processed%":"1"}},"id":3023,"infowindow_disable":false},{"source":"post","title":"Senior Project Manager","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Senior Project Manager\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Position Summary Our client is looking for a&nbsp;Senior Project Manager who is responsible for the end-to-end technical and project execution&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/senior-project-manager\/\" name=\"Senior Project Manager\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Position Summary Our client is looking for a&nbsp;Senior Project Manager who is responsible for the end-to-end technical and project execution&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\/senior-project-manager\/","zoom":19,"extra_fields":{"post_excerpt":"Position Summary Our client is looking for a&nbsp;Senior Project Manager who is responsible for the end-to-end technical and project execution&hellip;","post_content":"<h2><strong>Position Summary<\/strong><\/h2>\n<p>Our client is looking for a&nbsp;Senior Project Manager who is responsible for the end-to-end technical and project execution of mega-scale projects \u2014 from design and planning through fabrication, delivery, installation, and closeout. This role combines engineering expertise with full project management accountability to ensure projects are executed efficiently, on time, within budget, and in compliance with all quality and contractual requirements.<\/p>\n<p>Serving as both the technical authority and the primary customer interface, the Senior Project Manager leads internal cross\u2011functional teams and oversees the integration of engineering, production, quality, procurement, and scheduling activities throughout the project lifecycle.<\/p>\n<h2><strong>Key Responsibilities<\/strong><\/h2>\n<h3><strong>Customer &amp; Contract Management<\/strong><\/h3>\n<ul>\n<li>Serve as the main point of contact for customers throughout the entire project lifecycle.<\/li>\n<li>Review and interpret contracts, specifications, and change orders to ensure both technical and commercial compliance.<\/li>\n<li>Lead commercial discussions\u2014including billing, delivery schedules, and change requests\u2014in collaboration with Sales and Finance.<\/li>\n<li>Represent the company professionally, maintaining strong relationships and effectively managing customer expectations.<\/li>\n<\/ul>\n<h3><strong>2. Technical Design &amp; Execution<\/strong><\/h3>\n<ul>\n<li>Translate customer requirements into accurate, compliant technical design solutions.<\/li>\n<li>Validate engineering assumptions, calculations, and system configurations to ensure feasibility and alignment with customer needs.<\/li>\n<li>Oversee the creation and approval of drawings, documentation, and design packages in partnership with engineering teams.<\/li>\n<li>Troubleshoot complex technical issues, ensuring timely resolution to maintain project schedules.<\/li>\n<\/ul>\n<h3><strong>3. Project Planning &amp; Scheduling<\/strong><\/h3>\n<ul>\n<li>Develop detailed project plans, schedules, and resource forecasts.<\/li>\n<li>Coordinate internal functions\u2014including engineering, production, procurement, and quality\u2014to ensure alignment with project milestones.<\/li>\n<li>Monitor project progress, identifying risks and implementing corrective actions as needed.<\/li>\n<li>Ensure all project phases meet established deadlines and deliverables.<\/li>\n<\/ul>\n<h3><strong>4. Budgeting &amp; Cost Control<\/strong><\/h3>\n<ul>\n<li>Establish project budgets and manage costs throughout the lifecycle.<\/li>\n<li>Track spend against forecasts, identifying variances early and implementing cost\u2011control measures.<\/li>\n<li>Drive financial accountability across internal teams and ensure adherence to contractual terms.<\/li>\n<\/ul>\n<h3><strong>5. Quality &amp; Compliance Management<\/strong><\/h3>\n<ul>\n<li>Ensure project deliverables meet all engineering, quality, and regulatory requirements.<\/li>\n<li>Collaborate with Quality Assurance teams to address non\u2011conformance issues and implement corrective actions.<\/li>\n<li>Maintain complete, accurate documentation for audits, customer reviews, and project closeout.<\/li>\n<\/ul>\n<h3><strong>6. Cross\u2011Functional Leadership &amp; Collaboration<\/strong><\/h3>\n<ul>\n<li>Lead multidisciplinary project teams, providing direction, clarity, and support.<\/li>\n<li>Facilitate effective communication among internal stakeholders and external partners.<\/li>\n<li>Mentor junior project managers and contribute to continuous improvement initiatives across the organization.<\/li>\n<\/ul>\n<h2><strong>Qualifications<\/strong><\/h2>\n<h3><strong>Required<\/strong><\/h3>\n<ul>\n<li>Bachelor\u2019s degree in Engineering (Mechanical, Electrical, Civil, or related field) or equivalent technical experience.<\/li>\n<li>7+ years of project management experience in a technical, engineering\u2011driven environment.<\/li>\n<li>Proven success managing large\u2011scale, multi\u2011phase, customer\u2011facing projects.<\/li>\n<li>Strong understanding of engineering principles, fabrication processes, and technical documentation.<\/li>\n<li>Expertise in contract interpretation and change management.<\/li>\n<li>Proficiency in project management tools and ERP systems.<\/li>\n<li>Excellent communication, leadership, and problem\u2011solving skills.<\/li>\n<\/ul>\n<h3><strong>Preferred<\/strong><\/h3>\n<ul>\n<li>PMP or equivalent project management certification.<\/li>\n<li>Experience managing mega\u2011projects with budgets exceeding millions.<\/li>\n<li>Familiarity with lean manufacturing, quality systems, or regulated industries.<\/li><\/ul><p>This role will work out of our client's Dallas, Texas location.<\/p>","post_title":"Senior Project Manager","post_link":"https:\/\/turnerstaffing.com\/position\/senior-project-manager\/","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%":"<h2><strong>Position Summary<\/strong><\/h2>\n<p>Our client is looking for a&nbsp;Senior Project Manager who is responsible for the end-to-end technical and project execution of mega-scale projects \u2014 from design and planning through fabrication, delivery, installation, and closeout. This role combines engineering expertise with full project management accountability to ensure projects are executed efficiently, on time, within budget, and in compliance with all quality and contractual requirements.<\/p>\n<p>Serving as both the technical authority and the primary customer interface, the Senior Project Manager leads internal cross\u2011functional teams and oversees the integration of engineering, production, quality, procurement, and scheduling activities throughout the project lifecycle.<\/p>\n<h2><strong>Key Responsibilities<\/strong><\/h2>\n<h3><strong>Customer &amp; Contract Management<\/strong><\/h3>\n<ul>\n<li>Serve as the main point of contact for customers throughout the entire project lifecycle.<\/li>\n<li>Review and interpret contracts, specifications, and change orders to ensure both technical and commercial compliance.<\/li>\n<li>Lead commercial discussions\u2014including billing, delivery schedules, and change requests\u2014in collaboration with Sales and Finance.<\/li>\n<li>Represent the company professionally, maintaining strong relationships and effectively managing customer expectations.<\/li>\n<\/ul>\n<h3><strong>2. Technical Design &amp; Execution<\/strong><\/h3>\n<ul>\n<li>Translate customer requirements into accurate, compliant technical design solutions.<\/li>\n<li>Validate engineering assumptions, calculations, and system configurations to ensure feasibility and alignment with customer needs.<\/li>\n<li>Oversee the creation and approval of drawings, documentation, and design packages in partnership with engineering teams.<\/li>\n<li>Troubleshoot complex technical issues, ensuring timely resolution to maintain project schedules.<\/li>\n<\/ul>\n<h3><strong>3. Project Planning &amp; Scheduling<\/strong><\/h3>\n<ul>\n<li>Develop detailed project plans, schedules, and resource forecasts.<\/li>\n<li>Coordinate internal functions\u2014including engineering, production, procurement, and quality\u2014to ensure alignment with project milestones.<\/li>\n<li>Monitor project progress, identifying risks and implementing corrective actions as needed.<\/li>\n<li>Ensure all project phases meet established deadlines and deliverables.<\/li>\n<\/ul>\n<h3><strong>4. Budgeting &amp; Cost Control<\/strong><\/h3>\n<ul>\n<li>Establish project budgets and manage costs throughout the lifecycle.<\/li>\n<li>Track spend against forecasts, identifying variances early and implementing cost\u2011control measures.<\/li>\n<li>Drive financial accountability across internal teams and ensure adherence to contractual terms.<\/li>\n<\/ul>\n<h3><strong>5. Quality &amp; Compliance Management<\/strong><\/h3>\n<ul>\n<li>Ensure project deliverables meet all engineering, quality, and regulatory requirements.<\/li>\n<li>Collaborate with Quality Assurance teams to address non\u2011conformance issues and implement corrective actions.<\/li>\n<li>Maintain complete, accurate documentation for audits, customer reviews, and project closeout.<\/li>\n<\/ul>\n<h3><strong>6. Cross\u2011Functional Leadership &amp; Collaboration<\/strong><\/h3>\n<ul>\n<li>Lead multidisciplinary project teams, providing direction, clarity, and support.<\/li>\n<li>Facilitate effective communication among internal stakeholders and external partners.<\/li>\n<li>Mentor junior project managers and contribute to continuous improvement initiatives across the organization.<\/li>\n<\/ul>\n<h2><strong>Qualifications<\/strong><\/h2>\n<h3><strong>Required<\/strong><\/h3>\n<ul>\n<li>Bachelor\u2019s degree in Engineering (Mechanical, Electrical, Civil, or related field) or equivalent technical experience.<\/li>\n<li>7+ years of project management experience in a technical, engineering\u2011driven environment.<\/li>\n<li>Proven success managing large\u2011scale, multi\u2011phase, customer\u2011facing projects.<\/li>\n<li>Strong understanding of engineering principles, fabrication processes, and technical documentation.<\/li>\n<li>Expertise in contract interpretation and change management.<\/li>\n<li>Proficiency in project management tools and ERP systems.<\/li>\n<li>Excellent communication, leadership, and problem\u2011solving skills.<\/li>\n<\/ul>\n<h3><strong>Preferred<\/strong><\/h3>\n<ul>\n<li>PMP or equivalent project management certification.<\/li>\n<li>Experience managing mega\u2011projects with budgets exceeding millions.<\/li>\n<li>Familiarity with lean manufacturing, quality systems, or regulated industries.<\/li><\/ul><p>This role will work out of our client's Dallas, Texas location.<\/p>","%category%":"Other","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/e00e780f7c60-senior-project-manager","%breezy_id%":"e00e780f7c60","%breezy_friendly_id%":"e00e780f7c60-senior-project-manager","%breezy_created_date%":"2026-01-05T23:04:51.480Z","%breezy_updated_date%":"2026-01-08T20:58:38.652Z","%_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":3024,"infowindow_disable":false},{"source":"post","title":"Production Miner &#8211; Haul Truck","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Production Miner &#8211; Haul Truck\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Production Miner &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; Reports to:&nbsp;Foreman \u2013 Turner Mining Group Job Description: The Production Miner is a developing mining operator position&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/production-miner-haul-truck\/\" name=\"Production Miner &#8211; Haul Truck\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Production Miner &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; Reports to:&nbsp;Foreman \u2013 Turner Mining Group Job Description: The Production Miner is a developing mining operator position&hellip;","address":"Soda Springs, ID, USA","location":{"lat":"42.6543652","city":"Soda Springs","state":"ID","country":"United States","lng":"-111.6046687","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/production-miner-haul-truck\/","zoom":19,"extra_fields":{"post_excerpt":"Production Miner &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; Reports to:&nbsp;Foreman \u2013 Turner Mining Group Job Description: The Production Miner is a developing mining operator position&hellip;","post_content":"<p><strong>Production Miner<\/strong>    &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&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><strong>Reports to:&nbsp;<\/strong><strong>Foreman \u2013 Turner Mining Group<\/strong><\/p>\n<p><strong>Job Description:<\/strong><\/p>\n<p>The Production Miner is a developing mining operator position within Turner Mining Group. The successful candidate must live the Turner Values and be an outward example to others. This position must demonstrate a strong commitment to \u201cSafe Production\u201d through decision making, priorities, and client relations.<\/p>\n<p><strong>Objectives and Contributions:<\/strong><\/p>\n<p>The Production Miner is focused on key aspects that drive communication and safe production while maintaining a high level of efficiency, and preventative maintenance awareness requirements. The Production Miner demonstrates safety ownership at a personal level and holds other crew members to the same high standard.&nbsp; The Production Miner will train and develop into the Equipment Operator job scope while the Equipment operator is filling in for the Senior job duties.<\/p>\n<ul><li>Work with employees to ensure a high level of accuracy and engagement on hazard identification and control<\/li><li>Engage crews and leadership to define processes that motivate working towards common goals<\/li><li>Assist with MSHA regulatory task training and verify compliance to standards<\/li><li>Live the values as part of a visible daily decision-making process<\/li><li>Assist with training proficiency audits<\/li><li>Involvement in risk assessment processes at various levels of the organization<\/li><li>Holds themselves and others accountable for acting like an owner (taking care of equipment, not wasting resources, using time wisely, and being accountable for conditions and behaviors)<\/li><li>Maintains a high standard of housekeeping (machine and work areas)<\/li><\/ul>\n<p><u>Culture and Communication:<\/u><\/p>\n<ul><li>Can effectively communicate in English (multi-lingual preferred)<\/li><li>Participate in site and project leaders to identify areas of improvement<\/li><li>Work with crews to support proactive near miss reporting<\/li><li>Leads by example (walks the talk)<\/li><\/ul>\n<p><u>Systems:<\/u><\/p>\n<ul><li>Ability to perform quality pre-operation machine inspections (Based on mobile equipment physical demands analysis)<\/li><li>Accurately documents 5000-23 and training checklist requirements<\/li><li>Other regulatory &amp; internal \/ external forms as required<\/li><li>Maintains a valid and insurable driving license<\/li><\/ul>\n<p><u>Travel and New Site Development:<\/u><\/p>\n<p><u>Time and Interactions:<\/u><\/p>\n<ul><li>The Production Miner must be flexible on shift schedules (days and nights) to assist with training and production needs<\/li><li>The Production Miner will be self-starting, motivated, with a strong desire to be part of a team and to influence improvement. Communication is also critical to keep leadership and site-based personnel in the loop of successes, challenges, and any additional support that may be required<\/li><li>Excellent time management skills<\/li><\/ul>\n<p><u>Qualifications:<\/u><\/p>\n<ul><li>Willingness and ability to adhere to OSHA \/ MSHA regulatory requirements<\/li><li>Production Miner will be subject to a probationary period of six months from the date of hire<\/li><li>0-2 years\u2019 experience in mining \/ heavy industry preferred<\/li><li>Working knowledge of safety systems and processes<\/li><li>Appropriate attention to detail required<\/li><li>Strong communication skills<\/li><li>Strong morals and values<\/li><li>Exemplary attendance record<\/li><li>Exemplary safety and disciplinary record<\/li><li>Willingness to be flexible on daily job duty requirements<\/li><li>Maintains a positive outspoken learning attitude<\/li><li>The Production Miner will be competent and highly proficient on each piece of the following equipment:<ul><li><strong>Water truck,<\/strong><\/li><li><strong>Haulage Truck<\/strong><\/li><\/ul><\/li><\/ul>\n<p><u>Other Duties:<\/u><\/p>\n<ul><li>In addition to the job skills above, there may be requirements for manual tasks to be completed to meet other business needs. Operators in any job duty classification may be required to participate in these additional tasks.<\/li><\/ul>\n<p><u><strong>Benefits<\/strong><\/u><br>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. 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":"Production Miner &#8211; Haul Truck","post_link":"https:\/\/turnerstaffing.com\/position\/production-miner-haul-truck\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Associate","%location_country%":"United States","%location_city%":"Soda Springs","%location_state_id%":"ID","%location_state_name%":"Idaho","%location_city_state%":"Soda Springs, ID","%education%":"Unspecified","%department%":"Operations","%description%":"<p><strong>Production Miner<\/strong>    &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&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><strong>Reports to:&nbsp;<\/strong><strong>Foreman \u2013 Turner Mining Group<\/strong><\/p>\n<p><strong>Job Description:<\/strong><\/p>\n<p>The Production Miner is a developing mining operator position within Turner Mining Group. The successful candidate must live the Turner Values and be an outward example to others. This position must demonstrate a strong commitment to \u201cSafe Production\u201d through decision making, priorities, and client relations.<\/p>\n<p><strong>Objectives and Contributions:<\/strong><\/p>\n<p>The Production Miner is focused on key aspects that drive communication and safe production while maintaining a high level of efficiency, and preventative maintenance awareness requirements. The Production Miner demonstrates safety ownership at a personal level and holds other crew members to the same high standard.&nbsp; The Production Miner will train and develop into the Equipment Operator job scope while the Equipment operator is filling in for the Senior job duties.<\/p>\n<ul><li>Work with employees to ensure a high level of accuracy and engagement on hazard identification and control<\/li><li>Engage crews and leadership to define processes that motivate working towards common goals<\/li><li>Assist with MSHA regulatory task training and verify compliance to standards<\/li><li>Live the values as part of a visible daily decision-making process<\/li><li>Assist with training proficiency audits<\/li><li>Involvement in risk assessment processes at various levels of the organization<\/li><li>Holds themselves and others accountable for acting like an owner (taking care of equipment, not wasting resources, using time wisely, and being accountable for conditions and behaviors)<\/li><li>Maintains a high standard of housekeeping (machine and work areas)<\/li><\/ul>\n<p><u>Culture and Communication:<\/u><\/p>\n<ul><li>Can effectively communicate in English (multi-lingual preferred)<\/li><li>Participate in site and project leaders to identify areas of improvement<\/li><li>Work with crews to support proactive near miss reporting<\/li><li>Leads by example (walks the talk)<\/li><\/ul>\n<p><u>Systems:<\/u><\/p>\n<ul><li>Ability to perform quality pre-operation machine inspections (Based on mobile equipment physical demands analysis)<\/li><li>Accurately documents 5000-23 and training checklist requirements<\/li><li>Other regulatory &amp; internal \/ external forms as required<\/li><li>Maintains a valid and insurable driving license<\/li><\/ul>\n<p><u>Travel and New Site Development:<\/u><\/p>\n<p><u>Time and Interactions:<\/u><\/p>\n<ul><li>The Production Miner must be flexible on shift schedules (days and nights) to assist with training and production needs<\/li><li>The Production Miner will be self-starting, motivated, with a strong desire to be part of a team and to influence improvement. Communication is also critical to keep leadership and site-based personnel in the loop of successes, challenges, and any additional support that may be required<\/li><li>Excellent time management skills<\/li><\/ul>\n<p><u>Qualifications:<\/u><\/p>\n<ul><li>Willingness and ability to adhere to OSHA \/ MSHA regulatory requirements<\/li><li>Production Miner will be subject to a probationary period of six months from the date of hire<\/li><li>0-2 years\u2019 experience in mining \/ heavy industry preferred<\/li><li>Working knowledge of safety systems and processes<\/li><li>Appropriate attention to detail required<\/li><li>Strong communication skills<\/li><li>Strong morals and values<\/li><li>Exemplary attendance record<\/li><li>Exemplary safety and disciplinary record<\/li><li>Willingness to be flexible on daily job duty requirements<\/li><li>Maintains a positive outspoken learning attitude<\/li><li>The Production Miner will be competent and highly proficient on each piece of the following equipment:<ul><li><strong>Water truck,<\/strong><\/li><li><strong>Haulage Truck<\/strong><\/li><\/ul><\/li><\/ul>\n<p><u>Other Duties:<\/u><\/p>\n<ul><li>In addition to the job skills above, there may be requirements for manual tasks to be completed to meet other business needs. Operators in any job duty classification may be required to participate in these additional tasks.<\/li><\/ul>\n<p><u><strong>Benefits<\/strong><\/u><br>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. 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\/066d2deebbab-production-miner-haul-truck","%breezy_id%":"066d2deebbab","%breezy_friendly_id%":"066d2deebbab-production-miner-haul-truck","%breezy_created_date%":"2025-12-31T14:31:08.247Z","%breezy_updated_date%":"2025-12-31T14:32:27.297Z","%_wpgmp_location_city%":"Soda Springs","%_wpgmp_location_state%":"ID","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Soda Springs, ID, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"42.6543652","%_wpgmp_metabox_longitude%":"-111.6046687","%rank_math_internal_links_processed%":"1"}},"id":3016,"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 Production Miner (Haul Truck) We are looking for a dynamic and talented mining Haul Truck Drivers&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/haul-truck-driver-mining-4\/\" name=\"Haul Truck Driver &#8211; Mining\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Turner Mining Group \u2013 Production Miner (Haul Truck) We are looking for a dynamic and talented mining Haul Truck Drivers&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-mining-4\/","zoom":19,"extra_fields":{"post_excerpt":"Turner Mining Group \u2013 Production Miner (Haul Truck) We are looking for a dynamic and talented mining Haul Truck Drivers&hellip;","post_content":"<p style=\"color:#555555\"><strong><span style=\"text-decoration:underline\">Turner Mining Group \u2013 Production Miner (Haul Truck)<\/span><\/strong><br><\/p>\n\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-mining-4\/","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 Production Miner (Haul Truck)<\/span><\/strong><br><\/p>\n\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\/c767e51a171f-haul-truck-driver-mining","%breezy_id%":"c767e51a171f","%breezy_friendly_id%":"c767e51a171f-haul-truck-driver-mining","%breezy_created_date%":"2025-12-29T16:14:40.838Z","%breezy_updated_date%":"2025-12-29T16:15:07.884Z","%_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":3009,"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-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-mining-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-mining-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-12-29T16:13:29.685Z","%_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":3007,"infowindow_disable":false},{"source":"post","title":"HR Generalist","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    HR Generalist\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Human Resources Generalist Reports to: Human Resources Manager \u2013 Turner Mining Group Department: Human Resources Job Description: The HR Generalist&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/hr-generalist\/\" name=\"HR Generalist\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Human Resources Generalist Reports to: Human Resources Manager \u2013 Turner Mining Group Department: Human Resources Job Description: The HR Generalist&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\/hr-generalist\/","zoom":19,"extra_fields":{"post_excerpt":"Human Resources Generalist Reports to: Human Resources Manager \u2013 Turner Mining Group Department: Human Resources Job Description: The HR Generalist&hellip;","post_content":"<p><strong>Human Resources Generalist<\/strong><\/p>\n<p>Reports to: Human Resources Manager \u2013 Turner Mining Group Department: Human Resources<\/p>\n<p><strong>Job Description:<\/strong><\/p>\n<p>The HR Generalist plays a vital role in supporting Turner Mining Group\u2019s mission of creating a positive, engaging, and compliant workplace where people thrive. This role partners closely with employees and leaders across the company to support the entire employee lifecycle. From onboarding and engagement through employee relations, performance management, and development.<\/p>\n<p>The HR Generalist will serve as a trusted point of contact for all employee matters, acting with professionalism, confidentiality, and integrity. This position is instrumental in fostering a culture that embodies Turner\u2019s Core Values:<\/p>\n<p>\u2022 Heart for People \u2013 Build trust, listen, and support employees with care and empathy.<\/p>\n<p>\u2022 Eye for Safety \u2013 Promote a safe, compliant, and respectful workplace.<\/p>\n<p>\u2022 Mind for Innovation \u2013 Continuously seek better processes, tools, and programs that improve the employee experience.<\/p>\n<p>\u2022 Attitude for Excellence \u2013 Deliver timely, high-quality work that drives company success.<\/p>\n<p>This position will be onsite with the opportunity for hybrid flexibility once fully integrated into the role.<\/p>\n<p><strong>Objectives and Contributions:<\/strong><\/p>\n<p>The HR Generalist supports a broad range of HR responsibilities designed to enhance Turner\u2019s culture and operational effectiveness. Success in this role is measured by strong collaboration, reliable execution, and the ability to proactively identify and implement people-focused solutions.<\/p>\n<p>- Serve as an employee advocate and trusted resource for all HR-related questions, concerns, and requests.<\/p>\n<p>- Provide HR support to leaders in areas such as talent management, performance, and employee relations.<\/p>\n<p>- Partner with the People Operations team to support the staffing and onboarding process for hourly and salaried roles, including coordination with operations teams.<\/p>\n<p>- Support and advise on leave management, benefits, and compliance with the HR team.<\/p>\n<p>- Lead or assist in workplace investigations with professionalism, ensuring objective, timely resolutions and proper documentation.<\/p>\n<p>- Support and maintain compliance with federal, state, and local employment laws and company policies.<\/p>\n<p>- Assist in the development, implementation, and improvement of HR programs such as onboarding, performance management, training, and recognition initiatives.<\/p>\n<p>- Support compensation processes such as merit reviews, job changes, and market adjustments in partnership with Business and HR leadership.<\/p>\n<p>- Assist in planning and supporting employee engagement, wellness, and recognition initiatives.<br><\/p>\n\n<p>- Generate, review, and validate HR metrics (including turnover, retention, and training completion) to ensure accuracy, supports improvements, and decision-making.<\/p>\n<p>- Maintain accurate employee files, training records, and HR documentation in compliance with company and legal standards.<\/p>\n<p>- Foster open communication, collaboration, and engagement between employees, supervisors, and leadership.<\/p>\n<p>Each team member makes a significant contribution to Turner\u2019s success. While the primary duties are outlined here, this description does not limit the scope of responsibilities. All employees are expected to contribute wherever needed to achieve Turner Mining Group\u2019s mission and uphold its values.<\/p>\n<p><strong>Culture and Communication:<\/strong><\/p>\n<p>- Builds positive relationships with employees at all levels, demonstrating empathy and fairness in every interaction.<\/p>\n<p>- Communicates clearly, effectively, and respectfully \u2014 both verbally and in writing.<\/p>\n<p>- Leads by example, consistently demonstrating Turner\u2019s Core Values in behavior and decision-making.<\/p>\n<p>- Helps maintain a workplace culture focused on safety, accountability, and respect.<\/p>\n<p><strong>Systems:<\/strong><\/p>\n<p>- Maintains HRIS and other HR systems (ADP Workforce Now, Breezy HR, exc.) with accuracy and confidentiality.<\/p>\n<p>- Understands and applies relevant employment laws and regulations including FMLA, ADA, FLSA, COBRA, and related state requirements.<\/p>\n<p>- Assists in monitoring, auditing, and updating HR policies and procedures to align with compliance and company standards.<\/p>\n<p>- Supports training program coordination, tracking completions for required courses such as Harassment Prevention and MSHA trainings.<\/p>\n<p><strong>Time and Interactions:<\/strong><\/p>\n<p>- Full-time, primarily onsite (5 days\/week) with opportunity for hybrid flexibility after initial onboarding period.<\/p>\n<p>- Regular and predictable attendance required.<\/p>\n<p>- Collaborates daily with People Operations, Payroll, Safety, and Site Leadership teams to provide proactive HR support.<\/p>\n<p>- Travel may be required to sites depending on business needs.<\/p>\n<p>- Must be adaptable, managing multiple competing priorities while maintaining accuracy and professionalism in a fast-paced, dynamic environment.<\/p>\n<p><strong>Qualifications:<\/strong><\/p>\n<p>- Bachelor\u2019s degree in Human Resources, Business, or related field preferred.<\/p>\n<p>- 3\u20135 years of progressive HR experience; experience in field-based or construction\/mining environment a plus.<\/p>\n<p>- Proficiency with Microsoft Office Suite (Word, Excel, PowerPoint, Smartsheet).<\/p>\n<p>- Experience with ADP Workforce Now and applicant tracking systems (such as Breezy HR) preferred.<\/p>\n<p>- Strong working knowledge of HR compliance and employment law.<br><\/p>\n\n<p>- Demonstrated ability to build relationships, handle confidential information, and manage sensitive employee matters with discretion.<\/p>\n<p>- Bilingual (English\/Spanish) preferred.<\/p>\n<p>- Strong problem-solving, communication, and decision-making skills.<\/p>\n<p>- Self-starter with initiative to anticipate needs and drive continuous improvement.<\/p>\n<p><strong>Physical Demands &amp; Work Environment:<\/strong><\/p>\n<p>- Work is primarily light in nature with frequent sitting at a computer for extended periods (7\u20138 hours per day).<\/p>\n<p>- Must be able to move about the office, access files, and communicate effectively in person and via phone or video.<\/p>\n<p>- Manual dexterity to operate office equipment (computer, copier, phone, etc.).<\/p>\n<p>- Visual acuity to read and interpret documents and digital information.<\/p>\n<p>- Ability to occasionally lift up to 20 pounds.<\/p>\n<p>- All employment is contingent upon successful completion of a background check.<\/p>","post_title":"HR Generalist","post_link":"https:\/\/turnerstaffing.com\/position\/hr-generalist\/","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%":"","%description%":"<p><strong>Human Resources Generalist<\/strong><\/p>\n<p>Reports to: Human Resources Manager \u2013 Turner Mining Group Department: Human Resources<\/p>\n<p><strong>Job Description:<\/strong><\/p>\n<p>The HR Generalist plays a vital role in supporting Turner Mining Group\u2019s mission of creating a positive, engaging, and compliant workplace where people thrive. This role partners closely with employees and leaders across the company to support the entire employee lifecycle. From onboarding and engagement through employee relations, performance management, and development.<\/p>\n<p>The HR Generalist will serve as a trusted point of contact for all employee matters, acting with professionalism, confidentiality, and integrity. This position is instrumental in fostering a culture that embodies Turner\u2019s Core Values:<\/p>\n<p>\u2022 Heart for People \u2013 Build trust, listen, and support employees with care and empathy.<\/p>\n<p>\u2022 Eye for Safety \u2013 Promote a safe, compliant, and respectful workplace.<\/p>\n<p>\u2022 Mind for Innovation \u2013 Continuously seek better processes, tools, and programs that improve the employee experience.<\/p>\n<p>\u2022 Attitude for Excellence \u2013 Deliver timely, high-quality work that drives company success.<\/p>\n<p>This position will be onsite with the opportunity for hybrid flexibility once fully integrated into the role.<\/p>\n<p><strong>Objectives and Contributions:<\/strong><\/p>\n<p>The HR Generalist supports a broad range of HR responsibilities designed to enhance Turner\u2019s culture and operational effectiveness. Success in this role is measured by strong collaboration, reliable execution, and the ability to proactively identify and implement people-focused solutions.<\/p>\n<p>- Serve as an employee advocate and trusted resource for all HR-related questions, concerns, and requests.<\/p>\n<p>- Provide HR support to leaders in areas such as talent management, performance, and employee relations.<\/p>\n<p>- Partner with the People Operations team to support the staffing and onboarding process for hourly and salaried roles, including coordination with operations teams.<\/p>\n<p>- Support and advise on leave management, benefits, and compliance with the HR team.<\/p>\n<p>- Lead or assist in workplace investigations with professionalism, ensuring objective, timely resolutions and proper documentation.<\/p>\n<p>- Support and maintain compliance with federal, state, and local employment laws and company policies.<\/p>\n<p>- Assist in the development, implementation, and improvement of HR programs such as onboarding, performance management, training, and recognition initiatives.<\/p>\n<p>- Support compensation processes such as merit reviews, job changes, and market adjustments in partnership with Business and HR leadership.<\/p>\n<p>- Assist in planning and supporting employee engagement, wellness, and recognition initiatives.<br><\/p>\n\n<p>- Generate, review, and validate HR metrics (including turnover, retention, and training completion) to ensure accuracy, supports improvements, and decision-making.<\/p>\n<p>- Maintain accurate employee files, training records, and HR documentation in compliance with company and legal standards.<\/p>\n<p>- Foster open communication, collaboration, and engagement between employees, supervisors, and leadership.<\/p>\n<p>Each team member makes a significant contribution to Turner\u2019s success. While the primary duties are outlined here, this description does not limit the scope of responsibilities. All employees are expected to contribute wherever needed to achieve Turner Mining Group\u2019s mission and uphold its values.<\/p>\n<p><strong>Culture and Communication:<\/strong><\/p>\n<p>- Builds positive relationships with employees at all levels, demonstrating empathy and fairness in every interaction.<\/p>\n<p>- Communicates clearly, effectively, and respectfully \u2014 both verbally and in writing.<\/p>\n<p>- Leads by example, consistently demonstrating Turner\u2019s Core Values in behavior and decision-making.<\/p>\n<p>- Helps maintain a workplace culture focused on safety, accountability, and respect.<\/p>\n<p><strong>Systems:<\/strong><\/p>\n<p>- Maintains HRIS and other HR systems (ADP Workforce Now, Breezy HR, exc.) with accuracy and confidentiality.<\/p>\n<p>- Understands and applies relevant employment laws and regulations including FMLA, ADA, FLSA, COBRA, and related state requirements.<\/p>\n<p>- Assists in monitoring, auditing, and updating HR policies and procedures to align with compliance and company standards.<\/p>\n<p>- Supports training program coordination, tracking completions for required courses such as Harassment Prevention and MSHA trainings.<\/p>\n<p><strong>Time and Interactions:<\/strong><\/p>\n<p>- Full-time, primarily onsite (5 days\/week) with opportunity for hybrid flexibility after initial onboarding period.<\/p>\n<p>- Regular and predictable attendance required.<\/p>\n<p>- Collaborates daily with People Operations, Payroll, Safety, and Site Leadership teams to provide proactive HR support.<\/p>\n<p>- Travel may be required to sites depending on business needs.<\/p>\n<p>- Must be adaptable, managing multiple competing priorities while maintaining accuracy and professionalism in a fast-paced, dynamic environment.<\/p>\n<p><strong>Qualifications:<\/strong><\/p>\n<p>- Bachelor\u2019s degree in Human Resources, Business, or related field preferred.<\/p>\n<p>- 3\u20135 years of progressive HR experience; experience in field-based or construction\/mining environment a plus.<\/p>\n<p>- Proficiency with Microsoft Office Suite (Word, Excel, PowerPoint, Smartsheet).<\/p>\n<p>- Experience with ADP Workforce Now and applicant tracking systems (such as Breezy HR) preferred.<\/p>\n<p>- Strong working knowledge of HR compliance and employment law.<br><\/p>\n\n<p>- Demonstrated ability to build relationships, handle confidential information, and manage sensitive employee matters with discretion.<\/p>\n<p>- Bilingual (English\/Spanish) preferred.<\/p>\n<p>- Strong problem-solving, communication, and decision-making skills.<\/p>\n<p>- Self-starter with initiative to anticipate needs and drive continuous improvement.<\/p>\n<p><strong>Physical Demands &amp; Work Environment:<\/strong><\/p>\n<p>- Work is primarily light in nature with frequent sitting at a computer for extended periods (7\u20138 hours per day).<\/p>\n<p>- Must be able to move about the office, access files, and communicate effectively in person and via phone or video.<\/p>\n<p>- Manual dexterity to operate office equipment (computer, copier, phone, etc.).<\/p>\n<p>- Visual acuity to read and interpret documents and digital information.<\/p>\n<p>- Ability to occasionally lift up to 20 pounds.<\/p>\n<p>- All employment is contingent upon successful completion of a background check.<\/p>","%category%":"Human Resources","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/2cc29cc612fe-hr-generalist","%breezy_id%":"2cc29cc612fe","%breezy_friendly_id%":"2cc29cc612fe-hr-generalist","%breezy_created_date%":"2025-12-23T14:06:21.873Z","%breezy_updated_date%":"2025-12-23T14:07:48.321Z","%_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":3005,"infowindow_disable":false},{"source":"post","title":"Heavy Equipment Fuel &amp; Lube Technician","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Heavy Equipment Fuel &amp; Lube Technician\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Heavy Equipment Fuel &amp; Lube Technician Job Description We are looking for a dynamic and talented professional to fill a&nbsp;Fuel&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/fuel-lube-technician-3\/\" name=\"Heavy Equipment Fuel &amp; Lube Technician\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Heavy Equipment Fuel &amp; Lube Technician Job Description We are looking for a dynamic and talented professional to fill a&nbsp;Fuel&hellip;","address":"Lamesa, TX, USA","location":{"lat":"32.7376001","city":"Lamesa","state":"TX","country":"United States","lng":"-101.950992","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/fuel-lube-technician-3\/","zoom":19,"extra_fields":{"post_excerpt":"Heavy Equipment Fuel &amp; Lube Technician Job Description We are looking for a dynamic and talented professional to fill a&nbsp;Fuel&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\">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 &amp; Lube Technician","post_link":"https:\/\/turnerstaffing.com\/position\/fuel-lube-technician-3\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"","%location_country%":"United States","%location_city%":"Lamesa","%location_state_id%":"TX","%location_state_name%":"Texas","%location_city_state%":"Lamesa, 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;\">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\/1f814acff231-heavy-equipment-fuel-lube-technician","%breezy_id%":"1f814acff231","%breezy_friendly_id%":"1f814acff231-heavy-equipment-fuel-lube-technician","%breezy_created_date%":"2025-12-17T01:08:59.478Z","%breezy_updated_date%":"2025-12-30T22:42:56.420Z","%_wpgmp_location_city%":"Lamesa","%_wpgmp_location_state%":"TX","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Lamesa, TX, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"32.7376001","%_wpgmp_metabox_longitude%":"-101.950992","%rank_math_internal_links_processed%":"1"}},"id":2998,"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 Midwestern region,&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/field-services-technician-3\/\" 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 Midwestern region,&hellip;","address":"Milwaukee, WI, USA","location":{"lat":"43.0410344","city":"Milwaukee","state":"WI","country":"United States","lng":"-87.9096783","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/field-services-technician-3\/","zoom":19,"extra_fields":{"post_excerpt":"POSITION SUMMARY: The Field Service Technician will be responsible for providing field support for customer accounts in the Midwestern region,&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 Midwestern region, based out of the Milwaukee, Wisconsin metro area. 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-3\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Mid Level","%location_country%":"United States","%location_city%":"Milwaukee","%location_state_id%":"WI","%location_state_name%":"Wisconsin","%location_city_state%":"Milwaukee, WI","%education%":"High School or Equivalent","%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 Midwestern region, based out of the Milwaukee, Wisconsin metro area. 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%":"Operations","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/370f270203c7-field-services-technician","%breezy_id%":"370f270203c7","%breezy_friendly_id%":"370f270203c7-field-services-technician","%breezy_created_date%":"2025-12-12T18:13:27.967Z","%breezy_updated_date%":"2025-12-12T18:16:54.078Z","%_wpgmp_location_city%":"Milwaukee","%_wpgmp_location_state%":"WI","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Milwaukee, WI, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"43.0410344","%_wpgmp_metabox_longitude%":"-87.9096783","%rank_math_internal_links_processed%":"1"}},"id":2983,"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 Midwestern region,&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/field-services-technician-4\/\" 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 Midwestern region,&hellip;","address":"Elkhart, IN, USA","location":{"lat":"41.6062253","city":"Elkhart","state":"IN","country":"United States","lng":"-85.8486236","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/field-services-technician-4\/","zoom":19,"extra_fields":{"post_excerpt":"POSITION SUMMARY: The Field Service Technician will be responsible for providing field support for customer accounts in the Midwestern region,&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 Midwestern region, based out of the Elkhart, Indiana metro area. 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-4\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Mid Level","%location_country%":"United States","%location_city%":"Elkhart","%location_state_id%":"IN","%location_state_name%":"Indiana","%location_city_state%":"Elkhart, IN","%education%":"High School or Equivalent","%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 Midwestern region, based out of the Elkhart, Indiana metro area. 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%":"Operations","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/277bcb1cede8-field-services-technician","%breezy_id%":"277bcb1cede8","%breezy_friendly_id%":"277bcb1cede8-field-services-technician","%breezy_created_date%":"2025-12-12T18:46:18.964Z","%breezy_updated_date%":"2025-12-12T18:48:07.362Z","%_wpgmp_location_city%":"Elkhart","%_wpgmp_location_state%":"IN","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Elkhart, IN, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"41.6062253","%_wpgmp_metabox_longitude%":"-85.8486236","%rank_math_internal_links_processed%":"1"}},"id":2984,"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 Midwestern region,&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/field-services-technician-2\/\" 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 Midwestern region,&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\/field-services-technician-2\/","zoom":19,"extra_fields":{"post_excerpt":"POSITION SUMMARY: The Field Service Technician will be responsible for providing field support for customer accounts in the Midwestern region,&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 Midwestern region, based out of the South Bend, Indiana metro area. 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-2\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Mid Level","%location_country%":"United States","%location_city%":"South Bend","%location_state_id%":"IN","%location_state_name%":"Indiana","%location_city_state%":"South Bend, IN","%education%":"High School or Equivalent","%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 Midwestern region, based out of the South Bend, Indiana metro area. 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%":"Operations","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/39319fadbac4-field-services-technician","%breezy_id%":"39319fadbac4","%breezy_friendly_id%":"39319fadbac4-field-services-technician","%breezy_created_date%":"2025-12-12T17:58:51.215Z","%breezy_updated_date%":"2025-12-12T18:02:07.914Z","%_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":2982,"infowindow_disable":false},{"source":"post","title":"Field Engineer &#8211; Electrical Services","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Field Engineer &#8211; Electrical Services\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Field Engineer \u2013 Electrical Systems Location:&nbsp;Arizona, Travel-Based \/ Field Service Industry: Mining, Metals, Power, Manufacturing Primary Purpose Provide advanced electrical&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/field-engineer-electrical-services\/\" name=\"Field Engineer &#8211; Electrical Services\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Field Engineer \u2013 Electrical Systems Location:&nbsp;Arizona, Travel-Based \/ Field Service Industry: Mining, Metals, Power, Manufacturing Primary Purpose Provide advanced electrical&hellip;","address":", AZ, USA","location":{"lat":"34.0489281","state":"AZ","country":"United States","lng":"-111.0937311","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/field-engineer-electrical-services\/","zoom":19,"extra_fields":{"post_excerpt":"Field Engineer \u2013 Electrical Systems Location:&nbsp;Arizona, Travel-Based \/ Field Service Industry: Mining, Metals, Power, Manufacturing Primary Purpose Provide advanced electrical&hellip;","post_content":"<h1><strong>Field Engineer \u2013 Electrical Systems<\/strong><\/h1>\n<p><strong>Location:<\/strong>&nbsp;Arizona, Travel-Based \/ Field Service<br>\n<strong>Industry:<\/strong> Mining, Metals, Power, Manufacturing<\/p>\n<h2><strong>Primary Purpose<\/strong><\/h2>\n<p>Provide advanced electrical field engineering services for complex, non-routine equipment issues across multiple industrial sectors, including mining, steel mills, power plants, and manufacturing facilities. Work will occur at customer sites and internal service locations.<\/p>\n<h2><strong>Key Responsibilities<\/strong><\/h2>\n<h3><strong>Technical &amp; Engineering Support<\/strong><\/h3>\n<ul>\n<li>\n<p>Diagnose and troubleshoot vintage and modern control systems, including AC\/DC drive systems, PLCs, HMI automation platforms, and Siemens\/ABB VFD systems.<\/p>\n<\/li>\n<li>\n<p>Perform system setup, testing, calibration, and functional correlation on a variety of industrial drive and control systems.<\/p>\n<\/li>\n<li>\n<p>Provide technical support for complex maintenance and repair projects, including work on non-routine or never-before-serviced systems.<\/p>\n<\/li>\n<li>\n<p>Use DATAQ data loggers to capture XY recordings; prepare detailed reports and corrective-action recommendations.<\/p>\n<\/li>\n<li>\n<p>Maintain tools, test instruments, and equipment in proper working condition.<\/p>\n<\/li>\n<li>\n<p>Deliver after-hours technical support both remotely and on-site.<\/p>\n<\/li>\n<li>\n<p>Complete accurate service reports, time tracking, and expense documentation.<\/p>\n<\/li>\n<li>\n<p>Support on-the-job training and skill development for technicians and field engineers.<\/p>\n<\/li>\n<li>\n<p>Ensure required tools and equipment are available and in optimal condition for efficient work performance.<\/p>\n<\/li>\n<\/ul>\n<h3><strong>Customer Communication &amp; Project Support<\/strong><\/h3>\n<ul>\n<li>\n<p>Interface with plant engineers, maintenance teams, and operations personnel to resolve technical issues and clarify specifications.<\/p>\n<\/li>\n<li>\n<p>Provide technical details and repair scope information to internal teams for quotation development, including required parts and cost estimates.<\/p>\n<\/li>\n<li>\n<p>Keep appropriate internal stakeholders updated on project status, customer needs, and technical findings.<\/p>\n<\/li>\n<li>\n<p>Participate in identifying ongoing training needs related to repair, manufacturing, and field engineering.<\/p>\n<\/li>\n<li>\n<p>Mentor junior Field Engineers and contribute to developing team capabilities.<\/p>\n<\/li>\n<li>\n<p>Ensure all completed work meets established quality standards and complies with ISO-based processes.<\/p>\n<\/li>\n<li>\n<p>Communicate clearly, accurately, and professionally with employees, customers, and vendors.<\/p>\n<\/li>\n<\/ul>\n<h3><strong>General &amp; Safety Responsibilities<\/strong><\/h3>\n<ul>\n<li>\n<p>Follow all safety procedures and utilize proper PPE.<\/p>\n<\/li>\n<li>\n<p>Maintain a clean, organized, and safe work environment.<\/p>\n<\/li>\n<li>\n<p>Operate all equipment safely and responsibly.<\/p>\n<\/li>\n<li>\n<p>Uphold a strong professional image and maintain positive working relationships with customers, vendors, and coworkers.<\/p>\n<\/li>\n<li>\n<p>Provide exceptional customer service at all times.<\/p>\n<\/li>\n<li>\n<p>Follow all company policies, procedures, and work standards.<\/p>\n<\/li>\n<li>\n<p>Perform additional duties as assigned.<\/p>\n<\/li>\n<\/ul>\n<h2><strong>Requirements<\/strong><\/h2>\n<h3><strong>Education<\/strong><\/h3>\n<ul>\n<li>\n<p>Bachelor\u2019s degree in Electrical Engineering, or an equivalent combination of education and related experience.<\/p>\n<\/li>\n<\/ul>\n<h3><strong>Experience<\/strong><\/h3>\n<ul>\n<li>\n<p>4\u20137 years of electrical engineering experience in industrial field service or a comparable environment.<\/p>\n<\/li>\n<li>\n<p>Experience in mining, mills, power plants, or manufacturing facilities preferred.<\/p>\n<\/li>\n<li>\n<p>PLC and industrial drive system experience required.<\/p>\n<\/li>\n<li>\n<p>Manufacturer-specific product training preferred.<\/p>\n<\/li>\n<li>\n<p>Knowledge of AC\/DC motors strongly preferred.<\/p>\n<\/li>\n<\/ul>\n<h3><strong>Technical Skills<\/strong><\/h3>\n<ul>\n<li>\n<p>Strong working knowledge of PLCs, VFDs, HMI automation systems, and industrial troubleshooting methods.<\/p>\n<\/li>\n<li>\n<p>Broad exposure to multiple industrial applications and heavy equipment systems.<\/p>\n<\/li>\n<li>\n<p>Proficient in algebra, trigonometry, and analytical geometry.<\/p>\n<\/li>\n<li>\n<p>Strong PC skills, including Microsoft Office.<\/p>\n<\/li>\n<\/ul>\n<h3><strong>Professional Skills<\/strong><\/h3>\n<ul>\n<li>\n<p>Ability to work independently with minimal supervision.<\/p>\n<\/li>\n<li>\n<p>Strong written and verbal communication skills.<\/p>\n<\/li>\n<li>\n<p>Strong interpersonal and customer-facing skills.<\/p>\n<\/li>\n<li>\n<p>Effective organizational and time-management abilities with the capacity to manage multiple high-priority tasks.<\/p>\n<\/li>\n<li>\n<p>Demonstrated problem-solving and analytical troubleshooting capability.<\/p>\n<\/li>\n<li>\n<p>Ability to comprehend complex technical documentation and follow detailed procedures.<\/p>\n<\/li>\n<li>\n<p>Capable of making sound decisions on non-routine tasks.<\/p>\n<\/li>\n<li>\n<p>Willingness and ability to take after-hours calls.<\/p>\n<\/li>\n<li>\n<p>Overnight travel required.<\/p>\n<\/li>\n<li>\n<p>Valid driver\u2019s license required.<\/p>\n<\/li>\n<\/ul>\n<h2><strong>Values &amp; Behaviors<\/strong><\/h2>\n<p>The ideal candidate:<\/p>\n<ul>\n<li>\n<p>Cares deeply about people and safety<\/p>\n<\/li>\n<li>\n<p>Acts with humility, integrity, and trustworthiness<\/p>\n<\/li>\n<li>\n<p>Demonstrates resilience and persistence<\/p>\n<\/li>\n<li>\n<p>Embraces continuous learning and growth<\/p>\n<\/li>\n<li>\n<p>Delivers excellence in all aspects of their work<\/p><\/li><\/ul>","post_title":"Field Engineer &#8211; Electrical Services","post_link":"https:\/\/turnerstaffing.com\/position\/field-engineer-electrical-services\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"","%location_country%":"United States","%location_city%":"","%location_state_id%":"AZ","%location_state_name%":"Arizona","%location_city_state%":"United States","%education%":"","%department%":"","%description%":"<h1><strong>Field Engineer \u2013 Electrical Systems<\/strong><\/h1>\n<p><strong>Location:<\/strong>&nbsp;Arizona, Travel-Based \/ Field Service<br>\n<strong>Industry:<\/strong> Mining, Metals, Power, Manufacturing<\/p>\n<h2><strong>Primary Purpose<\/strong><\/h2>\n<p>Provide advanced electrical field engineering services for complex, non-routine equipment issues across multiple industrial sectors, including mining, steel mills, power plants, and manufacturing facilities. Work will occur at customer sites and internal service locations.<\/p>\n<h2><strong>Key Responsibilities<\/strong><\/h2>\n<h3><strong>Technical &amp; Engineering Support<\/strong><\/h3>\n<ul>\n<li>\n<p>Diagnose and troubleshoot vintage and modern control systems, including AC\/DC drive systems, PLCs, HMI automation platforms, and Siemens\/ABB VFD systems.<\/p>\n<\/li>\n<li>\n<p>Perform system setup, testing, calibration, and functional correlation on a variety of industrial drive and control systems.<\/p>\n<\/li>\n<li>\n<p>Provide technical support for complex maintenance and repair projects, including work on non-routine or never-before-serviced systems.<\/p>\n<\/li>\n<li>\n<p>Use DATAQ data loggers to capture XY recordings; prepare detailed reports and corrective-action recommendations.<\/p>\n<\/li>\n<li>\n<p>Maintain tools, test instruments, and equipment in proper working condition.<\/p>\n<\/li>\n<li>\n<p>Deliver after-hours technical support both remotely and on-site.<\/p>\n<\/li>\n<li>\n<p>Complete accurate service reports, time tracking, and expense documentation.<\/p>\n<\/li>\n<li>\n<p>Support on-the-job training and skill development for technicians and field engineers.<\/p>\n<\/li>\n<li>\n<p>Ensure required tools and equipment are available and in optimal condition for efficient work performance.<\/p>\n<\/li>\n<\/ul>\n<h3><strong>Customer Communication &amp; Project Support<\/strong><\/h3>\n<ul>\n<li>\n<p>Interface with plant engineers, maintenance teams, and operations personnel to resolve technical issues and clarify specifications.<\/p>\n<\/li>\n<li>\n<p>Provide technical details and repair scope information to internal teams for quotation development, including required parts and cost estimates.<\/p>\n<\/li>\n<li>\n<p>Keep appropriate internal stakeholders updated on project status, customer needs, and technical findings.<\/p>\n<\/li>\n<li>\n<p>Participate in identifying ongoing training needs related to repair, manufacturing, and field engineering.<\/p>\n<\/li>\n<li>\n<p>Mentor junior Field Engineers and contribute to developing team capabilities.<\/p>\n<\/li>\n<li>\n<p>Ensure all completed work meets established quality standards and complies with ISO-based processes.<\/p>\n<\/li>\n<li>\n<p>Communicate clearly, accurately, and professionally with employees, customers, and vendors.<\/p>\n<\/li>\n<\/ul>\n<h3><strong>General &amp; Safety Responsibilities<\/strong><\/h3>\n<ul>\n<li>\n<p>Follow all safety procedures and utilize proper PPE.<\/p>\n<\/li>\n<li>\n<p>Maintain a clean, organized, and safe work environment.<\/p>\n<\/li>\n<li>\n<p>Operate all equipment safely and responsibly.<\/p>\n<\/li>\n<li>\n<p>Uphold a strong professional image and maintain positive working relationships with customers, vendors, and coworkers.<\/p>\n<\/li>\n<li>\n<p>Provide exceptional customer service at all times.<\/p>\n<\/li>\n<li>\n<p>Follow all company policies, procedures, and work standards.<\/p>\n<\/li>\n<li>\n<p>Perform additional duties as assigned.<\/p>\n<\/li>\n<\/ul>\n<h2><strong>Requirements<\/strong><\/h2>\n<h3><strong>Education<\/strong><\/h3>\n<ul>\n<li>\n<p>Bachelor\u2019s degree in Electrical Engineering, or an equivalent combination of education and related experience.<\/p>\n<\/li>\n<\/ul>\n<h3><strong>Experience<\/strong><\/h3>\n<ul>\n<li>\n<p>4\u20137 years of electrical engineering experience in industrial field service or a comparable environment.<\/p>\n<\/li>\n<li>\n<p>Experience in mining, mills, power plants, or manufacturing facilities preferred.<\/p>\n<\/li>\n<li>\n<p>PLC and industrial drive system experience required.<\/p>\n<\/li>\n<li>\n<p>Manufacturer-specific product training preferred.<\/p>\n<\/li>\n<li>\n<p>Knowledge of AC\/DC motors strongly preferred.<\/p>\n<\/li>\n<\/ul>\n<h3><strong>Technical Skills<\/strong><\/h3>\n<ul>\n<li>\n<p>Strong working knowledge of PLCs, VFDs, HMI automation systems, and industrial troubleshooting methods.<\/p>\n<\/li>\n<li>\n<p>Broad exposure to multiple industrial applications and heavy equipment systems.<\/p>\n<\/li>\n<li>\n<p>Proficient in algebra, trigonometry, and analytical geometry.<\/p>\n<\/li>\n<li>\n<p>Strong PC skills, including Microsoft Office.<\/p>\n<\/li>\n<\/ul>\n<h3><strong>Professional Skills<\/strong><\/h3>\n<ul>\n<li>\n<p>Ability to work independently with minimal supervision.<\/p>\n<\/li>\n<li>\n<p>Strong written and verbal communication skills.<\/p>\n<\/li>\n<li>\n<p>Strong interpersonal and customer-facing skills.<\/p>\n<\/li>\n<li>\n<p>Effective organizational and time-management abilities with the capacity to manage multiple high-priority tasks.<\/p>\n<\/li>\n<li>\n<p>Demonstrated problem-solving and analytical troubleshooting capability.<\/p>\n<\/li>\n<li>\n<p>Ability to comprehend complex technical documentation and follow detailed procedures.<\/p>\n<\/li>\n<li>\n<p>Capable of making sound decisions on non-routine tasks.<\/p>\n<\/li>\n<li>\n<p>Willingness and ability to take after-hours calls.<\/p>\n<\/li>\n<li>\n<p>Overnight travel required.<\/p>\n<\/li>\n<li>\n<p>Valid driver\u2019s license required.<\/p>\n<\/li>\n<\/ul>\n<h2><strong>Values &amp; Behaviors<\/strong><\/h2>\n<p>The ideal candidate:<\/p>\n<ul>\n<li>\n<p>Cares deeply about people and safety<\/p>\n<\/li>\n<li>\n<p>Acts with humility, integrity, and trustworthiness<\/p>\n<\/li>\n<li>\n<p>Demonstrates resilience and persistence<\/p>\n<\/li>\n<li>\n<p>Embraces continuous learning and growth<\/p>\n<\/li>\n<li>\n<p>Delivers excellence in all aspects of their work<\/p><\/li><\/ul>","%category%":"Operations","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/b089089f55c9-field-engineer-electrical-services","%breezy_id%":"b089089f55c9","%breezy_friendly_id%":"b089089f55c9-field-engineer-electrical-services","%breezy_created_date%":"2025-12-11T15:45:06.258Z","%breezy_updated_date%":"2025-12-11T15:46:07.351Z","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"AZ","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":", AZ, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"34.0489281","%_wpgmp_metabox_longitude%":"-111.0937311","%rank_math_internal_links_processed%":"1"}},"id":2975,"infowindow_disable":false},{"source":"post","title":"Paving Equipment Manager","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Paving Equipment Manager\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Paving Equipment Manager Full-Time | Field-Based Role About the Role The Paving Equipment Manager is the key equipment leader in&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/paving-equipment-manager\/\" name=\"Paving Equipment Manager\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Paving Equipment Manager Full-Time | Field-Based Role About the Role The Paving Equipment Manager is the key equipment leader in&hellip;","address":"Charleston, SC, USA","location":{"lat":"32.7833163","city":"Charleston","state":"SC","country":"United States","lng":"-79.9319664","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/paving-equipment-manager\/","zoom":19,"extra_fields":{"post_excerpt":"Paving Equipment Manager Full-Time | Field-Based Role About the Role The Paving Equipment Manager is the key equipment leader in&hellip;","post_content":"<h1><strong>Paving Equipment Manager<\/strong><\/h1>\n<p><strong>Full-Time | Field-Based Role<\/strong><\/p>\n<h2><strong>About the Role<\/strong><\/h2>\n<p>The Paving Equipment Manager is the key equipment leader in the field, responsible for driving operator accountability, improving equipment uptime, and lowering maintenance costs. This role serves as the link between field paving crews and the Equipment Division\u2014promoting a strong culture of equipment ownership, optimizing maintenance planning, and leading continuous improvement efforts across all paving operations.<\/p>\n<h2><strong>Key Responsibilities<\/strong><\/h2>\n<h3><strong>1. Strengthen Operator Care &amp; Accountability<\/strong><\/h3>\n<ul>\n<li>\n<p>Oversee and audit daily equipment upkeep across paving crews.<\/p>\n<\/li>\n<li>\n<p>Promote a culture of equipment ownership by enforcing Operator Care Standards.<\/p>\n<\/li>\n<li>\n<p>Train superintendents and foremen on equipment care expectations and accountability practices.<\/p>\n<\/li>\n<li>\n<p>Serve as the primary liaison between paving crews and the Equipment Division, ensuring clear communication and timely follow-up on field conditions and needs.<\/p>\n<\/li>\n<\/ul>\n<h3><strong>2. Improve Equipment Uptime Through Data &amp; Analytics<\/strong><\/h3>\n<ul>\n<li>\n<p>Develop, track, and analyze key equipment metrics such as downtime, utilization, emergency work orders, inspection rates, repair costs, wear-item history, ANA, and more.<\/p>\n<\/li>\n<li>\n<p>Identify trends, root causes, and improvement opportunities using equipment inspection and performance data.<\/p>\n<\/li>\n<li>\n<p>Prepare and present regular reports outlining findings, corrective actions, and measurable improvements.<\/p>\n<\/li>\n<\/ul>\n<h3><strong>3. Partner With the Equipment Division to Optimize Fleet Performance<\/strong><\/h3>\n<ul>\n<li>\n<p>Collaborate with the Equipment Superintendent to implement comprehensive maintenance plans.<\/p>\n<\/li>\n<li>\n<p>Maintain \u201csuper-user\u201d level proficiency with all equipment maintenance software platforms.<\/p>\n<\/li>\n<li>\n<p>Lead wear-item tracking, measurement, and forecasting for major paving equipment.<\/p>\n<\/li>\n<li>\n<p>Develop and manage detailed Job Plans for repeat major repairs to boost mechanic efficiency and consistency.<\/p>\n<\/li>\n<\/ul>\n<h2><strong>Qualifications<\/strong><\/h2>\n<ul>\n<li>\n<p>Experience working with heavy equipment, paving operations, or equipment fleet management required.<\/p>\n<\/li>\n<li>\n<p>Strong understanding of equipment maintenance, repair processes, and operator best practices.<\/p>\n<\/li>\n<li>\n<p>Ability to analyze data, identify root causes, and drive corrective action.<\/p>\n<\/li>\n<li>\n<p>Skilled communicator capable of training crews and influencing field accountability.<\/p>\n<\/li>\n<li>\n<p>Strong organization, follow-up, and planning abilities.<\/p>\n<\/li>\n<li>\n<p>Proficiency with equipment software platforms or ability to quickly learn them.<\/p>\n<\/li>\n<\/ul>","post_title":"Paving Equipment Manager","post_link":"https:\/\/turnerstaffing.com\/position\/paving-equipment-manager\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Associate","%location_country%":"United States","%location_city%":"Charleston","%location_state_id%":"SC","%location_state_name%":"South Carolina","%location_city_state%":"Charleston, SC","%education%":"","%department%":"","%description%":"<h1><strong>Paving Equipment Manager<\/strong><\/h1>\n<p><strong>Full-Time | Field-Based Role<\/strong><\/p>\n<h2><strong>About the Role<\/strong><\/h2>\n<p>The Paving Equipment Manager is the key equipment leader in the field, responsible for driving operator accountability, improving equipment uptime, and lowering maintenance costs. This role serves as the link between field paving crews and the Equipment Division\u2014promoting a strong culture of equipment ownership, optimizing maintenance planning, and leading continuous improvement efforts across all paving operations.<\/p>\n<h2><strong>Key Responsibilities<\/strong><\/h2>\n<h3><strong>1. Strengthen Operator Care &amp; Accountability<\/strong><\/h3>\n<ul>\n<li>\n<p>Oversee and audit daily equipment upkeep across paving crews.<\/p>\n<\/li>\n<li>\n<p>Promote a culture of equipment ownership by enforcing Operator Care Standards.<\/p>\n<\/li>\n<li>\n<p>Train superintendents and foremen on equipment care expectations and accountability practices.<\/p>\n<\/li>\n<li>\n<p>Serve as the primary liaison between paving crews and the Equipment Division, ensuring clear communication and timely follow-up on field conditions and needs.<\/p>\n<\/li>\n<\/ul>\n<h3><strong>2. Improve Equipment Uptime Through Data &amp; Analytics<\/strong><\/h3>\n<ul>\n<li>\n<p>Develop, track, and analyze key equipment metrics such as downtime, utilization, emergency work orders, inspection rates, repair costs, wear-item history, ANA, and more.<\/p>\n<\/li>\n<li>\n<p>Identify trends, root causes, and improvement opportunities using equipment inspection and performance data.<\/p>\n<\/li>\n<li>\n<p>Prepare and present regular reports outlining findings, corrective actions, and measurable improvements.<\/p>\n<\/li>\n<\/ul>\n<h3><strong>3. Partner With the Equipment Division to Optimize Fleet Performance<\/strong><\/h3>\n<ul>\n<li>\n<p>Collaborate with the Equipment Superintendent to implement comprehensive maintenance plans.<\/p>\n<\/li>\n<li>\n<p>Maintain \u201csuper-user\u201d level proficiency with all equipment maintenance software platforms.<\/p>\n<\/li>\n<li>\n<p>Lead wear-item tracking, measurement, and forecasting for major paving equipment.<\/p>\n<\/li>\n<li>\n<p>Develop and manage detailed Job Plans for repeat major repairs to boost mechanic efficiency and consistency.<\/p>\n<\/li>\n<\/ul>\n<h2><strong>Qualifications<\/strong><\/h2>\n<ul>\n<li>\n<p>Experience working with heavy equipment, paving operations, or equipment fleet management required.<\/p>\n<\/li>\n<li>\n<p>Strong understanding of equipment maintenance, repair processes, and operator best practices.<\/p>\n<\/li>\n<li>\n<p>Ability to analyze data, identify root causes, and drive corrective action.<\/p>\n<\/li>\n<li>\n<p>Skilled communicator capable of training crews and influencing field accountability.<\/p>\n<\/li>\n<li>\n<p>Strong organization, follow-up, and planning abilities.<\/p>\n<\/li>\n<li>\n<p>Proficiency with equipment software platforms or ability to quickly learn them.<\/p>\n<\/li>\n<\/ul>","%category%":"","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/e2be3bcf7297-paving-equipment-manager","%breezy_id%":"e2be3bcf7297","%breezy_friendly_id%":"e2be3bcf7297-paving-equipment-manager","%breezy_created_date%":"2025-12-10T14:09:59.223Z","%breezy_updated_date%":"2025-12-10T14:11:39.585Z","%_wpgmp_location_city%":"Charleston","%_wpgmp_location_state%":"SC","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Charleston, SC, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"32.7833163","%_wpgmp_metabox_longitude%":"-79.9319664","%rank_math_internal_links_processed%":"1"}},"id":2967,"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-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 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-2\/","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<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%":"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<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\/302139128d89-dozer-operator","%breezy_id%":"302139128d89","%breezy_friendly_id%":"302139128d89-dozer-operator","%breezy_created_date%":"2025-12-10T18:16:30.369Z","%breezy_updated_date%":"2025-12-10T18:16:38.408Z","%_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":2969,"infowindow_disable":false},{"source":"post","title":"AC Winder II","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    AC Winder II\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Primary Purpose: Rewind various kinds of basic to moderately complex electromechanical equipment including removing the original winding, inspecting for winding&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/ac-winder-ii\/\" name=\"AC Winder II\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Primary Purpose: Rewind various kinds of basic to moderately complex electromechanical equipment including removing the original winding, inspecting for winding&hellip;","address":"Casper, WY, USA","location":{"lat":"42.848709","city":"Casper","state":"WY","country":"United States","lng":"-106.2980824","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/ac-winder-ii\/","zoom":19,"extra_fields":{"post_excerpt":"Primary Purpose: Rewind various kinds of basic to moderately complex electromechanical equipment including removing the original winding, inspecting for winding&hellip;","post_content":"<p>Primary Purpose:  Rewind various kinds of basic to moderately complex electromechanical equipment including removing the original winding, inspecting for winding failure damage, recording data from the original winding, making new coils, winding, and performing voltage testing on windings. <\/p>\n<p>Essential Functions: <\/p>\n<p>\u2022\tWinding \u2013 Performs under limited supervision. <\/p>\n<p>o \tRewind various kinds of electromechanical equipment, including but not limited to single-phase stators, threephase stators, three phase rotors, fields, and coils. Operate proper insulating techniques and\/or requirements during rewinding. <\/p>\n<p>o\tDismantle and\/or strip damaged or unserviceable electromechanical equipment, including media blasting. <\/p>\n<p>o\tInspect various kinds of electromechanical equipment for winding damage and evidence of electrical malfunctions. <\/p>\n<p>o\tDocument\/record all relevant data specific to unit\u2019s electromagnetic characteristics, operating conditions, existing damage, or intended serviceability. <\/p>\n<p>o\tPrepare all reusable parts for rewinding and inspect renewed parts for hidden, structural damage or unusual conditions. <\/p>\n<p>o\tWind various electromechanical equipment. <\/p>\n<p>o \tTest rewound electromechanical equipment according to EASA Standards and document test results. <\/p>\n<p>o \tComplete required paperwork for each job accurately and on a timely basis. <\/p>\n<p>o \tOperate specified repair and testing equipment, including but not limited to  winding machines, test panels, surge testers, Hipot, core-loss testers, cut-off saws, burnout ovens, bake ovens, grinders, cranes, forklift trucks, pallet trucks, brazing units, dip tanks, VPI systems, and various hand held power and non-power tools. <\/p>\n<p>\u2022\tOther o Observe all safety procedures and use proper safety equipment including eye, ear, and hand protection. <\/p>\n<p>o       Maintain a clean, neat, and safe work environment at all times. o Operate and maintain equipment in a safe manner at all times.   <\/p>\n<p>o\tPromote strong company image and maintain positive working relationships at all times including professional behavior with customers and co-workers including coordinators. <\/p>\n<p>o\tProvide outstanding customer service at all times. <\/p>\n<p>o \tPerform work according to established company policies and procedures. <\/p>\n<p>o\tPerform other duties as requested. <\/p>\n<p>Requirements: <\/p>\n<p>\u2022\tEducation:   <\/p>\n<p>o High school diploma or equivalent. <\/p>\n<p>\u2022\tExperience:   <\/p>\n<p>o\tTwo years of winding experience. <\/p>\n<p>\u2022\tOther: <\/p>\n<p>o\tAbility to perform basic math functions including addition, subtraction, multiplication, division including understanding fractions. <\/p>\n<p>o\tAbility to read, write, and comprehend simple to complex written and verbal instructions. o \tAbility to understand, perform, and retain various job related training, operational, and safety procedures. o \tAbility to exercise initiative, judgment, and decision making related to routine duties within set company standards.  <\/p>\n<p>o\tAbility to operate machinery and hoists. <\/p>\n<p>o\tKnowledge of small machine shop machines required. <\/p>\n<p>o\tVery infrequent travel may be required.<\/p>","post_title":"AC Winder II","post_link":"https:\/\/turnerstaffing.com\/position\/ac-winder-ii\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Associate","%location_country%":"United States","%location_city%":"Casper","%location_state_id%":"WY","%location_state_name%":"Wyoming","%location_city_state%":"Casper, WY","%education%":"High School or Equivalent","%department%":"","%description%":"<p>Primary Purpose:  Rewind various kinds of basic to moderately complex electromechanical equipment including removing the original winding, inspecting for winding failure damage, recording data from the original winding, making new coils, winding, and performing voltage testing on windings. <\/p>\n<p>Essential Functions: <\/p>\n<p>\u2022\tWinding \u2013 Performs under limited supervision. <\/p>\n<p>o \tRewind various kinds of electromechanical equipment, including but not limited to single-phase stators, threephase stators, three phase rotors, fields, and coils. Operate proper insulating techniques and\/or requirements during rewinding. <\/p>\n<p>o\tDismantle and\/or strip damaged or unserviceable electromechanical equipment, including media blasting. <\/p>\n<p>o\tInspect various kinds of electromechanical equipment for winding damage and evidence of electrical malfunctions. <\/p>\n<p>o\tDocument\/record all relevant data specific to unit\u2019s electromagnetic characteristics, operating conditions, existing damage, or intended serviceability. <\/p>\n<p>o\tPrepare all reusable parts for rewinding and inspect renewed parts for hidden, structural damage or unusual conditions. <\/p>\n<p>o\tWind various electromechanical equipment. <\/p>\n<p>o \tTest rewound electromechanical equipment according to EASA Standards and document test results. <\/p>\n<p>o \tComplete required paperwork for each job accurately and on a timely basis. <\/p>\n<p>o \tOperate specified repair and testing equipment, including but not limited to  winding machines, test panels, surge testers, Hipot, core-loss testers, cut-off saws, burnout ovens, bake ovens, grinders, cranes, forklift trucks, pallet trucks, brazing units, dip tanks, VPI systems, and various hand held power and non-power tools. <\/p>\n<p>\u2022\tOther o Observe all safety procedures and use proper safety equipment including eye, ear, and hand protection. <\/p>\n<p>o       Maintain a clean, neat, and safe work environment at all times. o Operate and maintain equipment in a safe manner at all times.   <\/p>\n<p>o\tPromote strong company image and maintain positive working relationships at all times including professional behavior with customers and co-workers including coordinators. <\/p>\n<p>o\tProvide outstanding customer service at all times. <\/p>\n<p>o \tPerform work according to established company policies and procedures. <\/p>\n<p>o\tPerform other duties as requested. <\/p>\n<p>Requirements: <\/p>\n<p>\u2022\tEducation:   <\/p>\n<p>o High school diploma or equivalent. <\/p>\n<p>\u2022\tExperience:   <\/p>\n<p>o\tTwo years of winding experience. <\/p>\n<p>\u2022\tOther: <\/p>\n<p>o\tAbility to perform basic math functions including addition, subtraction, multiplication, division including understanding fractions. <\/p>\n<p>o\tAbility to read, write, and comprehend simple to complex written and verbal instructions. o \tAbility to understand, perform, and retain various job related training, operational, and safety procedures. o \tAbility to exercise initiative, judgment, and decision making related to routine duties within set company standards.  <\/p>\n<p>o\tAbility to operate machinery and hoists. <\/p>\n<p>o\tKnowledge of small machine shop machines required. <\/p>\n<p>o\tVery infrequent travel may be required.<\/p>","%category%":"Operations","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/9a748c54ec1d-ac-winder-ii","%breezy_id%":"9a748c54ec1d","%breezy_friendly_id%":"9a748c54ec1d-ac-winder-ii","%breezy_created_date%":"2025-12-09T20:27:30.912Z","%breezy_updated_date%":"2026-01-23T20:49:35.138Z","%_wpgmp_location_city%":"Casper","%_wpgmp_location_state%":"WY","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Casper, WY, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"42.848709","%_wpgmp_metabox_longitude%":"-106.2980824","%rank_math_internal_links_processed%":"1"}},"id":2966,"infowindow_disable":false},{"source":"post","title":"Tanker Truck Driver","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Tanker Truck Driver\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    POSITION SUMMARY: Load and deliver lime slurry to the customers. Complete Pre\/Post Inspections on equipment the ensure DOT regulations are&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/pneumatic-truck-driver\/\" name=\"Tanker Truck Driver\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"POSITION SUMMARY: Load and deliver lime slurry to the customers. Complete Pre\/Post Inspections on equipment the ensure DOT regulations are&hellip;","address":"New Braunfels, , USA","location":{"lat":"29.702566","city":"New Braunfels","country":"United States","lng":"-98.1240635","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/pneumatic-truck-driver\/","zoom":19,"extra_fields":{"post_excerpt":"POSITION SUMMARY: Load and deliver lime slurry to the customers. Complete Pre\/Post Inspections on equipment the ensure DOT regulations are&hellip;","post_content":"<p><strong>POSITION SUMMARY: <\/strong><\/p>\n<p>Load and deliver lime slurry to the customers. Complete Pre\/Post Inspections on equipment the ensure DOT regulations are met.<\/p>\n<p>We have a pool of drivers hauling product from various terminals and Porta Batch production sites to the customer.<\/p>\n<p><\/p>\n<p><strong>RESPONSIBILITIES &amp; EXPECTATIONS:<\/strong><\/p>\n<p>Deliver slurry shipments in a safe and timely manner. Operation and Maintenance of Equipment:<\/p>\n<ul><li>Read and interpret various gauges and instruments used in loading and handling equipment.<\/li><li>Analyze and evaluate work conditions and make adjustments to equipment as necessary.<\/li><li>Perform equipment inspections in accordance with DOT requirements.<\/li><li>Make minor repairs to equipment as needed to maintain fleet operation.<\/li><\/ul>\n<p>Safety and Compliance:<\/p>\n<ul><li>Ensure the DOT, safety, TCEQ, and environmental regulations are followed.&nbsp;<\/li><\/ul>\n<p>Training:<\/p>\n<ul><li>Educate and train the local contractors in the safe handling of quicklime\/ slurry, and cover emergency medical procedures in case of accidental exposure.<\/li><\/ul>\n<p><\/p>\n<p><strong>ATTRIBUTES:<\/strong><\/p>\n<ul><li>Must have a Class A CDL with Pneumatic tanker endorsement (N).<\/li><li>Working knowledge of DOT regulations, fleet equipment, and excellent fleet mechanical skills.<\/li><li>Ability to maneuver fleet equipment in heavy city traffic and remote job locations.<\/li><li>Maintain concentration, alertness and attention to detail for an extended period.<\/li><li>Ability to resolve issues with limited supervision.<\/li><li>Occasional shift work, including some weekends and holidays.<\/li><li>Be available or volunteer for occasional out of state deliveries.<\/li><\/ul>\n<p><\/p>\n<p><strong>PHYSICAL DEMANDS INCLUDE, BUT ARE NOT LIMITED TO: <\/strong><\/p>\n<ul><li>Tolerate working outside in weather conditions as well as exposure to warm temperatures, noise, and lime dust.<\/li><li>Access all areas within a site which could include heights of 50 feet, confined spaces, and climbing ladders or stairs.<\/li><li>Ability to occasionally lift\/carry 20 pounds.<\/li><\/ul>\n<p><\/p>\n<p><\/p>\n<p>REQUIRED EDUCATION: &nbsp;&nbsp;Class A CDL &amp; Tanker endorsement (N)<br>PREFFERED EDUCATION:&nbsp;&nbsp; High School Diploma or GED equivalent.<br>REQUIRED EXPERIENCE:&nbsp;&nbsp; Verifiable CDL driving experience and\/or recent completion of CDL truck driving school.<br>PREFFERED EXPERIENCE:&nbsp;&nbsp; Two years of verifiable CDL driving experience.<\/p>","post_title":"Tanker Truck Driver","post_link":"https:\/\/turnerstaffing.com\/position\/pneumatic-truck-driver\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Associate","%location_country%":"United States","%location_city%":"New Braunfels","%location_state_id%":"","%location_state_name%":"","%location_city_state%":"New Braunfels, US","%education%":"High School or Equivalent","%department%":"","%description%":"<p><strong>POSITION SUMMARY: <\/strong><\/p>\n<p>Load and deliver lime slurry to the customers. Complete Pre\/Post Inspections on equipment the ensure DOT regulations are met.<\/p>\n<p>We have a pool of drivers hauling product from various terminals and Porta Batch production sites to the customer.<\/p>\n<p><\/p>\n<p><strong>RESPONSIBILITIES &amp; EXPECTATIONS:<\/strong><\/p>\n<p>Deliver slurry shipments in a safe and timely manner. Operation and Maintenance of Equipment:<\/p>\n<ul><li>Read and interpret various gauges and instruments used in loading and handling equipment.<\/li><li>Analyze and evaluate work conditions and make adjustments to equipment as necessary.<\/li><li>Perform equipment inspections in accordance with DOT requirements.<\/li><li>Make minor repairs to equipment as needed to maintain fleet operation.<\/li><\/ul>\n<p>Safety and Compliance:<\/p>\n<ul><li>Ensure the DOT, safety, TCEQ, and environmental regulations are followed.&nbsp;<\/li><\/ul>\n<p>Training:<\/p>\n<ul><li>Educate and train the local contractors in the safe handling of quicklime\/ slurry, and cover emergency medical procedures in case of accidental exposure.<\/li><\/ul>\n<p><\/p>\n<p><strong>ATTRIBUTES:<\/strong><\/p>\n<ul><li>Must have a Class A CDL with Pneumatic tanker endorsement (N).<\/li><li>Working knowledge of DOT regulations, fleet equipment, and excellent fleet mechanical skills.<\/li><li>Ability to maneuver fleet equipment in heavy city traffic and remote job locations.<\/li><li>Maintain concentration, alertness and attention to detail for an extended period.<\/li><li>Ability to resolve issues with limited supervision.<\/li><li>Occasional shift work, including some weekends and holidays.<\/li><li>Be available or volunteer for occasional out of state deliveries.<\/li><\/ul>\n<p><\/p>\n<p><strong>PHYSICAL DEMANDS INCLUDE, BUT ARE NOT LIMITED TO: <\/strong><\/p>\n<ul><li>Tolerate working outside in weather conditions as well as exposure to warm temperatures, noise, and lime dust.<\/li><li>Access all areas within a site which could include heights of 50 feet, confined spaces, and climbing ladders or stairs.<\/li><li>Ability to occasionally lift\/carry 20 pounds.<\/li><\/ul>\n<p><\/p>\n<p><\/p>\n<p>REQUIRED EDUCATION: &nbsp;&nbsp;Class A CDL &amp; Tanker endorsement (N)<br>PREFFERED EDUCATION:&nbsp;&nbsp; High School Diploma or GED equivalent.<br>REQUIRED EXPERIENCE:&nbsp;&nbsp; Verifiable CDL driving experience and\/or recent completion of CDL truck driving school.<br>PREFFERED EXPERIENCE:&nbsp;&nbsp; Two years of verifiable CDL driving experience.<\/p>","%category%":"Other","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/ec81a118dc6c-tanker-truck-driver","%breezy_id%":"ec81a118dc6c","%breezy_friendly_id%":"ec81a118dc6c-tanker-truck-driver","%breezy_created_date%":"2025-04-16T20:00:46.475Z","%breezy_updated_date%":"2026-01-21T22:27:35.831Z","%_wpgmp_location_city%":"New Braunfels","%_wpgmp_location_state%":"","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"New Braunfels, , 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":2956,"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    Location:&nbsp;Grantsville, UT.Schedule:&nbsp;Full-time | Overtime availablePay: $39.00- $42.00Growth:&nbsp;Excellent opportunity for long-term career advancement About the Role We are seeking a skilled&nbsp;Industrial&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/industrial-electrician-3\/\" name=\"Industrial Electrician\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Location:&nbsp;Grantsville, UT.Schedule:&nbsp;Full-time | Overtime availablePay: $39.00- $42.00Growth:&nbsp;Excellent opportunity for long-term career advancement About the Role We are seeking a skilled&nbsp;Industrial&hellip;","address":"Grantsville, UT, USA","location":{"lat":"40.5999425","city":"Grantsville","state":"UT","country":"United States","lng":"-112.4643988","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/industrial-electrician-3\/","zoom":19,"extra_fields":{"post_excerpt":"Location:&nbsp;Grantsville, UT.Schedule:&nbsp;Full-time | Overtime availablePay: $39.00- $42.00Growth:&nbsp;Excellent opportunity for long-term career advancement About the Role We are seeking a skilled&nbsp;Industrial&hellip;","post_content":"<p><strong>Location:<\/strong>&nbsp;Grantsville, UT.<br><strong>Schedule:<\/strong>&nbsp;Full-time | Overtime available<br><strong>Pay: $39.00- $42.00<\/strong><br><strong>Growth:<\/strong>&nbsp;Excellent opportunity for long-term career advancement<\/p>\n<h3><strong>About the Role<\/strong><\/h3>\n<p>We are seeking a skilled&nbsp;<strong>Industrial Electrician<\/strong>&nbsp;to join our team.&nbsp;This role supports a major limestone operation and requires strong troubleshooting skills, independence, and the ability to work in a fast-paced industrial environment.<br><\/p>\n\n<h3><strong>Responsibilities<\/strong><\/h3>\n<ul><li>Perform electrical installation, maintenance, and repair on industrial and mining equipment.<\/li><li>Troubleshoot&nbsp;<strong>480V systems<\/strong>, motors, motor controls, and power distribution.<\/li><li>Work with&nbsp;<strong>PLCs<\/strong>, including Allen-Bradley, for diagnostics and basic programming adjustments.<\/li><li>Maintain conveyors, crushers, screens, bag houses, and other aggregate processing equipment.<\/li><li>Perform electrical inspections and ensure compliance with company and safety standards.<\/li><li>Travel to various terminals across the West Coast to support electrical needs of the operation.<\/li><li>Document work performed and communicate effectively with supervisors and onsite teams.<\/li><\/ul>\n<h3><strong>Requirements<\/strong><\/h3>\n<ul><li><strong>3\u20135 years of industrial or mining electrical experience<\/strong>&nbsp;required.<\/li><li>Strong knowledge of&nbsp;<strong>480V<\/strong>, MCCs, motor controls, and troubleshooting.<\/li><li>Experience with&nbsp;<strong>Allen-Bradley PLCs<\/strong>&nbsp;(diagnostics, I\/O, VFDs, etc.).<\/li><li>Ability to read and interpret electrical schematics and blueprints.<\/li><li>Valid driver\u2019s license and clean driving record.<\/li><li>Strong safety mindset and ability to work independently or as part of a team.<\/li><\/ul>\n<h3><strong>What We Offer<\/strong><\/h3><ul><li><strong>Overtime opportunities<\/strong>.<\/li><li><strong>Job stability<\/strong>&nbsp;with a long-standing leader in the limestone industry.<\/li><li><strong>Growth potential<\/strong>&nbsp;into senior technician or supervisory roles.<\/li><li>Supportive, safety-driven work culture<\/li><\/ul>","post_title":"Industrial Electrician","post_link":"https:\/\/turnerstaffing.com\/position\/industrial-electrician-3\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Associate","%location_country%":"United States","%location_city%":"Grantsville","%location_state_id%":"UT","%location_state_name%":"Utah","%location_city_state%":"Grantsville, UT","%education%":"High School or Equivalent","%department%":"","%description%":"<p><strong>Location:<\/strong>&nbsp;Grantsville, UT.<br><strong>Schedule:<\/strong>&nbsp;Full-time | Overtime available<br><strong>Pay: $39.00- $42.00<\/strong><br><strong>Growth:<\/strong>&nbsp;Excellent opportunity for long-term career advancement<\/p>\n<h3><strong>About the Role<\/strong><\/h3>\n<p>We are seeking a skilled&nbsp;<strong>Industrial Electrician<\/strong>&nbsp;to join our team.&nbsp;This role supports a major limestone operation and requires strong troubleshooting skills, independence, and the ability to work in a fast-paced industrial environment.<br><\/p>\n\n<h3><strong>Responsibilities<\/strong><\/h3>\n<ul><li>Perform electrical installation, maintenance, and repair on industrial and mining equipment.<\/li><li>Troubleshoot&nbsp;<strong>480V systems<\/strong>, motors, motor controls, and power distribution.<\/li><li>Work with&nbsp;<strong>PLCs<\/strong>, including Allen-Bradley, for diagnostics and basic programming adjustments.<\/li><li>Maintain conveyors, crushers, screens, bag houses, and other aggregate processing equipment.<\/li><li>Perform electrical inspections and ensure compliance with company and safety standards.<\/li><li>Travel to various terminals across the West Coast to support electrical needs of the operation.<\/li><li>Document work performed and communicate effectively with supervisors and onsite teams.<\/li><\/ul>\n<h3><strong>Requirements<\/strong><\/h3>\n<ul><li><strong>3\u20135 years of industrial or mining electrical experience<\/strong>&nbsp;required.<\/li><li>Strong knowledge of&nbsp;<strong>480V<\/strong>, MCCs, motor controls, and troubleshooting.<\/li><li>Experience with&nbsp;<strong>Allen-Bradley PLCs<\/strong>&nbsp;(diagnostics, I\/O, VFDs, etc.).<\/li><li>Ability to read and interpret electrical schematics and blueprints.<\/li><li>Valid driver\u2019s license and clean driving record.<\/li><li>Strong safety mindset and ability to work independently or as part of a team.<\/li><\/ul>\n<h3><strong>What We Offer<\/strong><\/h3><ul><li><strong>Overtime opportunities<\/strong>.<\/li><li><strong>Job stability<\/strong>&nbsp;with a long-standing leader in the limestone industry.<\/li><li><strong>Growth potential<\/strong>&nbsp;into senior technician or supervisory roles.<\/li><li>Supportive, safety-driven work culture<\/li><\/ul>","%category%":"Other","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/aa568ed82ea5-industrial-electrician","%breezy_id%":"aa568ed82ea5","%breezy_friendly_id%":"aa568ed82ea5-industrial-electrician","%breezy_created_date%":"2025-12-03T20:29:55.080Z","%breezy_updated_date%":"2025-12-05T04:28:46.054Z","%_wpgmp_location_city%":"Grantsville","%_wpgmp_location_state%":"UT","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Grantsville, UT, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"40.5999425","%_wpgmp_metabox_longitude%":"-112.4643988","%rank_math_internal_links_processed%":"1"}},"id":2954,"infowindow_disable":false},{"source":"post","title":"Production Miner &#8211; Haul Truck","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Production Miner &#8211; Haul Truck\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Production Miner &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; Reports to: Foreman \u2013 Turner Mining Group Job Description: The Production Miner is a developing mining operator&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/production-miner\/\" name=\"Production Miner &#8211; Haul Truck\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Production Miner &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; Reports to: Foreman \u2013 Turner Mining Group Job Description: The Production Miner is a developing mining operator&hellip;","address":"Soda Spring, ID, USA","location":{"lat":"42.6543652","city":"Soda Spring","state":"ID","country":"United States","lng":"-111.6046687","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/production-miner\/","zoom":19,"extra_fields":{"post_excerpt":"Production Miner &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; Reports to: Foreman \u2013 Turner Mining Group Job Description: The Production Miner is a developing mining operator&hellip;","post_content":"<p><strong>Production Miner<\/strong>                    &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&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><strong>Reports to: <\/strong><strong>Foreman \u2013 Turner Mining Group<\/strong><\/p>\n<p><strong>Job Description:<\/strong><\/p>\n<p>The Production Miner is a developing mining operator position within Turner Mining Group. The successful candidate must live the Turner Values and be an outward example to others. This position must demonstrate a strong commitment to \u201cSafe Production\u201d through decision making, priorities, and client relations.<\/p>\n<p><strong>Objectives and Contributions:<\/strong><\/p>\n<p>The Production Miner is focused on key aspects that drive communication and safe production while maintaining a high level of efficiency, and preventative maintenance awareness requirements. The Production Miner demonstrates safety ownership at a personal level and holds other crew members to the same high standard.&nbsp; The Production Miner will train and develop into the Equipment Operator job scope while the Equipment operator is filling in for the Senior job duties.<\/p>\n<ul><li>Work with employees to ensure a high level of accuracy and engagement on hazard identification and control<\/li><li>Engage crews and leadership to define processes that motivate working towards common goals<\/li><li>Assist with MSHA regulatory task training and verify compliance to standards<\/li><li>Live the values as part of a visible daily decision-making process<\/li><li>Assist with training proficiency audits<\/li><li>Involvement in risk assessment processes at various levels of the organization<\/li><li>Holds themselves and others accountable for acting like an owner (taking care of equipment, not wasting resources, using time wisely, and being accountable for conditions and behaviors)<\/li><li>Maintains a high standard of housekeeping (machine and work areas)<\/li><\/ul>\n<p><u>Culture and Communication:<\/u><\/p>\n<ul><li>Can effectively communicate in English (multi-lingual preferred)<\/li><li>Participate in site and project leaders to identify areas of improvement<\/li><li>Work with crews to support proactive near miss reporting<\/li><li>Leads by example (walks the talk)<\/li><\/ul>\n<p><u>Systems:<\/u><\/p>\n<ul><li>Ability to perform quality pre-operation machine inspections (Based on mobile equipment physical demands analysis)<\/li><li>Accurately documents 5000-23 and training checklist requirements<\/li><li>Other regulatory &amp; internal \/ external forms as required<\/li><li>Maintains a valid and insurable driving license<\/li><\/ul>\n<p><u>Travel and New Site Development: <\/u><\/p>\n<p><u>Time and Interactions:<\/u><\/p>\n<ul><li>The Production Miner must be flexible on shift schedules (days and nights) to assist with training and production needs<\/li><li>The Production Miner will be self-starting, motivated, with a strong desire to be part of a team and to influence improvement. Communication is also critical to keep leadership and site-based personnel in the loop of successes, challenges, and any additional support that may be required<\/li><li>Excellent time management skills<\/li><\/ul>\n<p><u>Qualifications:<\/u><\/p>\n<ul><li>Willingness and ability to adhere to OSHA \/ MSHA regulatory requirements<\/li><li>Production Miner will be subject to a probationary period of six months from the date of hire<\/li><li>0-2 years\u2019 experience in mining \/ heavy industry preferred<\/li><li>Working knowledge of safety systems and processes<\/li><li>Appropriate attention to detail required<\/li><li>Strong communication skills<\/li><li>Strong morals and values<\/li><li>Exemplary attendance record<\/li><li>Exemplary safety and disciplinary record<\/li><li>Willingness to be flexible on daily job duty requirements<\/li><li>Maintains a positive outspoken learning attitude<\/li><li>The Production Miner will be competent and highly proficient on each piece of the following equipment: <ul><li><strong>Water truck,<\/strong><\/li><li><strong><\/strong><strong>Haulage Truck<\/strong><\/li><\/ul><\/li><\/ul>\n<p><u>Other Duties:<\/u><\/p>\n<ul><li>In addition to the job skills above, there may be requirements for manual tasks to be completed to meet other business needs. Operators in any job duty classification may be required to participate in these additional tasks.<\/li><\/ul>\n<p><u><strong>Benefits<\/strong><\/u><br>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. 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>\n<p><u><br><\/u><\/p>","post_title":"Production Miner &#8211; Haul Truck","post_link":"https:\/\/turnerstaffing.com\/position\/production-miner\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Entry Level","%location_country%":"United States","%location_city%":"Soda Spring","%location_state_id%":"ID","%location_state_name%":"Idaho","%location_city_state%":"Soda Spring, ID","%education%":"Unspecified","%department%":"Operations","%description%":"<p><strong>Production Miner<\/strong>                    &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&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><strong>Reports to: <\/strong><strong>Foreman \u2013 Turner Mining Group<\/strong><\/p>\n<p><strong>Job Description:<\/strong><\/p>\n<p>The Production Miner is a developing mining operator position within Turner Mining Group. The successful candidate must live the Turner Values and be an outward example to others. This position must demonstrate a strong commitment to \u201cSafe Production\u201d through decision making, priorities, and client relations.<\/p>\n<p><strong>Objectives and Contributions:<\/strong><\/p>\n<p>The Production Miner is focused on key aspects that drive communication and safe production while maintaining a high level of efficiency, and preventative maintenance awareness requirements. The Production Miner demonstrates safety ownership at a personal level and holds other crew members to the same high standard.&nbsp; The Production Miner will train and develop into the Equipment Operator job scope while the Equipment operator is filling in for the Senior job duties.<\/p>\n<ul><li>Work with employees to ensure a high level of accuracy and engagement on hazard identification and control<\/li><li>Engage crews and leadership to define processes that motivate working towards common goals<\/li><li>Assist with MSHA regulatory task training and verify compliance to standards<\/li><li>Live the values as part of a visible daily decision-making process<\/li><li>Assist with training proficiency audits<\/li><li>Involvement in risk assessment processes at various levels of the organization<\/li><li>Holds themselves and others accountable for acting like an owner (taking care of equipment, not wasting resources, using time wisely, and being accountable for conditions and behaviors)<\/li><li>Maintains a high standard of housekeeping (machine and work areas)<\/li><\/ul>\n<p><u>Culture and Communication:<\/u><\/p>\n<ul><li>Can effectively communicate in English (multi-lingual preferred)<\/li><li>Participate in site and project leaders to identify areas of improvement<\/li><li>Work with crews to support proactive near miss reporting<\/li><li>Leads by example (walks the talk)<\/li><\/ul>\n<p><u>Systems:<\/u><\/p>\n<ul><li>Ability to perform quality pre-operation machine inspections (Based on mobile equipment physical demands analysis)<\/li><li>Accurately documents 5000-23 and training checklist requirements<\/li><li>Other regulatory &amp; internal \/ external forms as required<\/li><li>Maintains a valid and insurable driving license<\/li><\/ul>\n<p><u>Travel and New Site Development: <\/u><\/p>\n<p><u>Time and Interactions:<\/u><\/p>\n<ul><li>The Production Miner must be flexible on shift schedules (days and nights) to assist with training and production needs<\/li><li>The Production Miner will be self-starting, motivated, with a strong desire to be part of a team and to influence improvement. Communication is also critical to keep leadership and site-based personnel in the loop of successes, challenges, and any additional support that may be required<\/li><li>Excellent time management skills<\/li><\/ul>\n<p><u>Qualifications:<\/u><\/p>\n<ul><li>Willingness and ability to adhere to OSHA \/ MSHA regulatory requirements<\/li><li>Production Miner will be subject to a probationary period of six months from the date of hire<\/li><li>0-2 years\u2019 experience in mining \/ heavy industry preferred<\/li><li>Working knowledge of safety systems and processes<\/li><li>Appropriate attention to detail required<\/li><li>Strong communication skills<\/li><li>Strong morals and values<\/li><li>Exemplary attendance record<\/li><li>Exemplary safety and disciplinary record<\/li><li>Willingness to be flexible on daily job duty requirements<\/li><li>Maintains a positive outspoken learning attitude<\/li><li>The Production Miner will be competent and highly proficient on each piece of the following equipment: <ul><li><strong>Water truck,<\/strong><\/li><li><strong><\/strong><strong>Haulage Truck<\/strong><\/li><\/ul><\/li><\/ul>\n<p><u>Other Duties:<\/u><\/p>\n<ul><li>In addition to the job skills above, there may be requirements for manual tasks to be completed to meet other business needs. Operators in any job duty classification may be required to participate in these additional tasks.<\/li><\/ul>\n<p><u><strong>Benefits<\/strong><\/u><br>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. 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>\n<p><u><br><\/u><\/p>","%category%":"Operations","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/4064c79b598c-production-miner-haul-truck","%breezy_id%":"4064c79b598c","%breezy_friendly_id%":"4064c79b598c-production-miner-haul-truck","%breezy_created_date%":"2025-12-03T16:02:25.968Z","%breezy_updated_date%":"2025-12-29T19:29:59.396Z","%_wpgmp_location_city%":"Soda Spring","%_wpgmp_location_state%":"ID","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Soda Spring, ID, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"42.6543652","%_wpgmp_metabox_longitude%":"-111.6046687","%rank_math_internal_links_processed%":"1"}},"id":2952,"infowindow_disable":false},{"source":"post","title":"Traveling Electrician","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Traveling Electrician\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Traveling Industrial Electrician (50\u201375% Travel) \u2013 Limestone \/ Aggregate Industry Location: West Coast Terminals (Travel required) Schedule: Full-time | Overtime&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/traveling-electrician\/\" name=\"Traveling Electrician\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Traveling Industrial Electrician (50\u201375% Travel) \u2013 Limestone \/ Aggregate Industry Location: West Coast Terminals (Travel required) Schedule: Full-time | Overtime&hellip;","address":"Grantsville, UT, USA","location":{"lat":"40.5999425","city":"Grantsville","state":"UT","country":"United States","lng":"-112.4643988","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/traveling-electrician\/","zoom":19,"extra_fields":{"post_excerpt":"Traveling Industrial Electrician (50\u201375% Travel) \u2013 Limestone \/ Aggregate Industry Location: West Coast Terminals (Travel required) Schedule: Full-time | Overtime&hellip;","post_content":"<p><strong>Traveling Industrial Electrician (50\u201375% Travel) \u2013 Limestone \/ Aggregate Industry<\/strong><\/p>\n<p><strong>Location:<\/strong> West Coast Terminals (Travel required)<br>\n<strong>Schedule:<\/strong> Full-time | Overtime available<br>\n<strong>Pay: $39.00- $42.00<\/strong><br>\n<strong>Travel:<\/strong> All travel paid (flights, hotel, and expenses)<br>\n<strong>Growth:<\/strong> Excellent opportunity for long-term career advancement<\/p>\n<h3><strong>About the Role<\/strong><\/h3>\n<p>We are seeking a skilled <strong>Industrial Electrician<\/strong> to join our team with the unique opportunity to travel <strong>50\u201375% of the time<\/strong> to our terminals across the West Coast. This role supports a major limestone operation and requires strong troubleshooting skills, independence, and the ability to work in a fast-paced industrial environment.<\/p>\n<p>Travel is fully paid, overtime is available, and there is significant room for growth within the company for the right candidate.<\/p>\n<h3><strong>Responsibilities<\/strong><\/h3>\n<ul>\n<li>\n<p>Perform electrical installation, maintenance, and repair on industrial and mining equipment.<\/p>\n<\/li>\n<li>\n<p>Troubleshoot <strong>480V systems<\/strong>, motors, motor controls, and power distribution.<\/p>\n<\/li>\n<li>\n<p>Work with <strong>PLCs<\/strong>, including Allen-Bradley, for diagnostics and basic programming adjustments.<\/p>\n<\/li>\n<li>\n<p>Maintain conveyors, crushers, screens, bag houses, and other aggregate processing equipment.<\/p>\n<\/li>\n<li>\n<p>Perform electrical inspections and ensure compliance with company and safety standards.<\/p>\n<\/li>\n<li>\n<p>Travel to various terminals across the West Coast to support electrical needs of the operation.<\/p>\n<\/li>\n<li>\n<p>Document work performed and communicate effectively with supervisors and onsite teams.<\/p>\n<\/li>\n<\/ul>\n<h3><strong>Requirements<\/strong><\/h3>\n<ul>\n<li>\n<p><strong>3\u20135 years of industrial or mining electrical experience<\/strong> required.<\/p>\n<\/li>\n<li>\n<p>Strong knowledge of <strong>480V<\/strong>, MCCs, motor controls, and troubleshooting.<\/p>\n<\/li>\n<li>\n<p>Experience with <strong>Allen-Bradley PLCs<\/strong> (diagnostics, I\/O, VFDs, etc.).<\/p>\n<\/li>\n<li>\n<p>Ability to read and interpret electrical schematics and blueprints.<\/p>\n<\/li>\n<li>\n<p>Comfortable traveling <strong>50\u201375%<\/strong> of the time.<\/p>\n<\/li>\n<li>\n<p>Valid driver\u2019s license and clean driving record.<\/p>\n<\/li>\n<li>\n<p>Strong safety mindset and ability to work independently or as part of a team.<\/p>\n<\/li>\n<\/ul>\n<h3><strong>What We Offer<\/strong><\/h3>\n<ul>\n<li>\n<p><strong>Paid travel<\/strong>: flights, hotels, all travel expenses including meals.<\/p>\n<\/li>\n<li>\n<p><strong>Overtime opportunities<\/strong>.<\/p>\n<\/li>\n<li>\n<p><strong>Job stability<\/strong> with a long-standing leader in the limestone industry.<\/p>\n<\/li>\n<li>\n<p><strong>Growth potential<\/strong> into senior technician or supervisory roles.<\/p>\n<\/li>\n<li>\n<p>Supportive, safety-driven work culture.<\/p><\/li><\/ul>","post_title":"Traveling Electrician","post_link":"https:\/\/turnerstaffing.com\/position\/traveling-electrician\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Associate","%location_country%":"United States","%location_city%":"Grantsville","%location_state_id%":"UT","%location_state_name%":"Utah","%location_city_state%":"Grantsville, UT","%education%":"High School or Equivalent","%department%":"","%description%":"<p><strong>Traveling Industrial Electrician (50\u201375% Travel) \u2013 Limestone \/ Aggregate Industry<\/strong><\/p>\n<p><strong>Location:<\/strong> West Coast Terminals (Travel required)<br>\n<strong>Schedule:<\/strong> Full-time | Overtime available<br>\n<strong>Pay: $39.00- $42.00<\/strong><br>\n<strong>Travel:<\/strong> All travel paid (flights, hotel, and expenses)<br>\n<strong>Growth:<\/strong> Excellent opportunity for long-term career advancement<\/p>\n<h3><strong>About the Role<\/strong><\/h3>\n<p>We are seeking a skilled <strong>Industrial Electrician<\/strong> to join our team with the unique opportunity to travel <strong>50\u201375% of the time<\/strong> to our terminals across the West Coast. This role supports a major limestone operation and requires strong troubleshooting skills, independence, and the ability to work in a fast-paced industrial environment.<\/p>\n<p>Travel is fully paid, overtime is available, and there is significant room for growth within the company for the right candidate.<\/p>\n<h3><strong>Responsibilities<\/strong><\/h3>\n<ul>\n<li>\n<p>Perform electrical installation, maintenance, and repair on industrial and mining equipment.<\/p>\n<\/li>\n<li>\n<p>Troubleshoot <strong>480V systems<\/strong>, motors, motor controls, and power distribution.<\/p>\n<\/li>\n<li>\n<p>Work with <strong>PLCs<\/strong>, including Allen-Bradley, for diagnostics and basic programming adjustments.<\/p>\n<\/li>\n<li>\n<p>Maintain conveyors, crushers, screens, bag houses, and other aggregate processing equipment.<\/p>\n<\/li>\n<li>\n<p>Perform electrical inspections and ensure compliance with company and safety standards.<\/p>\n<\/li>\n<li>\n<p>Travel to various terminals across the West Coast to support electrical needs of the operation.<\/p>\n<\/li>\n<li>\n<p>Document work performed and communicate effectively with supervisors and onsite teams.<\/p>\n<\/li>\n<\/ul>\n<h3><strong>Requirements<\/strong><\/h3>\n<ul>\n<li>\n<p><strong>3\u20135 years of industrial or mining electrical experience<\/strong> required.<\/p>\n<\/li>\n<li>\n<p>Strong knowledge of <strong>480V<\/strong>, MCCs, motor controls, and troubleshooting.<\/p>\n<\/li>\n<li>\n<p>Experience with <strong>Allen-Bradley PLCs<\/strong> (diagnostics, I\/O, VFDs, etc.).<\/p>\n<\/li>\n<li>\n<p>Ability to read and interpret electrical schematics and blueprints.<\/p>\n<\/li>\n<li>\n<p>Comfortable traveling <strong>50\u201375%<\/strong> of the time.<\/p>\n<\/li>\n<li>\n<p>Valid driver\u2019s license and clean driving record.<\/p>\n<\/li>\n<li>\n<p>Strong safety mindset and ability to work independently or as part of a team.<\/p>\n<\/li>\n<\/ul>\n<h3><strong>What We Offer<\/strong><\/h3>\n<ul>\n<li>\n<p><strong>Paid travel<\/strong>: flights, hotels, all travel expenses including meals.<\/p>\n<\/li>\n<li>\n<p><strong>Overtime opportunities<\/strong>.<\/p>\n<\/li>\n<li>\n<p><strong>Job stability<\/strong> with a long-standing leader in the limestone industry.<\/p>\n<\/li>\n<li>\n<p><strong>Growth potential<\/strong> into senior technician or supervisory roles.<\/p>\n<\/li>\n<li>\n<p>Supportive, safety-driven work culture.<\/p><\/li><\/ul>","%category%":"Other","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/4fc10a62bf96-traveling-electrician","%breezy_id%":"4fc10a62bf96","%breezy_friendly_id%":"4fc10a62bf96-traveling-electrician","%breezy_created_date%":"2025-12-03T20:25:25.676Z","%breezy_updated_date%":"2026-01-22T01:20:42.753Z","%_wpgmp_location_city%":"Grantsville","%_wpgmp_location_state%":"UT","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Grantsville, UT, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"40.5999425","%_wpgmp_metabox_longitude%":"-112.4643988","%rank_math_internal_links_processed%":"1"}},"id":2953,"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    POSITION SUMMARY:&nbsp; &nbsp;To perform electrical and instrumentation inspections, repairs and rebuilds on all plant operating equipment to ensure continuous operation&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/industrial-electrician-2\/\" name=\"Industrial Electrician\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"POSITION SUMMARY:&nbsp; &nbsp;To perform electrical and instrumentation inspections, repairs and rebuilds on all plant operating equipment to ensure continuous operation&hellip;","address":"Sherwood, TN, USA","location":{"lat":"35.0761938","city":"Sherwood","state":"TN","country":"United States","lng":"-85.9233121","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/industrial-electrician-2\/","zoom":19,"extra_fields":{"post_excerpt":"POSITION SUMMARY:&nbsp; &nbsp;To perform electrical and instrumentation inspections, repairs and rebuilds on all plant operating equipment to ensure continuous operation&hellip;","post_content":"<p><strong>POSITION SUMMARY:&nbsp; &nbsp;<\/strong>To perform electrical and instrumentation inspections, repairs and rebuilds on all plant operating equipment to ensure continuous operation within the required quality control standards. This role is critical to achieving Plant OEE and Equipment Availability goals by elimination of unplanned stops and extended downtimes. Incumbents in the position are required to participate in company-sponsored training and certification programs to ensure that their job knowledge and skills meet evolving company standards.<\/p>\n<p><\/p>\n<p><strong>RESPONSIBILITIES &amp; EXPECTATIONS: <\/strong><\/p>\n<ul><li>Must comply with company, state and governmental health and safety regulations at all times<\/li><\/ul>\n<ul><li>Must complete and document Workplace Inspections in a timely manner<\/li><li>Must be able to perform preventive maintenance checks and report findings (both verbally and in writing)<\/li><li>Must participate in the work order initiation process when required<\/li><li>Must ensure all inventory parts are correctly charged through work orders as per LNA procedures<\/li><li>Must possess a good knowledge of power distribution systems<\/li><li>Must be well versed in the installation, maintenance, and adjustment of transformers, motors, switches etc.<\/li><li>Must be able to perform low voltage and medium voltage terminations<\/li><li>Must be capable of performing maintenance on switchgear up to 480 volts<\/li><li>Must be capable of troubleshooting and maintaining all types of starters, vfd\u2019s etc.<\/li><li>Must be able to perform basic electrical calculations<\/li><li>Must be able to perform tasks with all electrical test equipment (volt meters, meggers, current generators, loop calibrators, etc)<\/li><li>Must be able to fabricate and install conduit<\/li><li>Must be able to perform soldering operations<\/li><li>Must be able to install and align electrical motors<\/li><li>Must be able to troubleshoot and maintain motor control circuits and air dryers<\/li><li>Must be able to maintain and replace control valves, actuators, and positioners &nbsp;<\/li><li>Must be proficient in the use of precision measuring tools (micrometers, dial indicators, etc)<\/li><li>Should possess some knowledge of the CMMS System and be willing to navigate the software correctly.<\/li><li>Must be familiar with thermography and fully understand the uses<\/li><li>Must be able to troubleshoot and perform repairs to hydraulic\/pneumatics systems<\/li><li>Must be able to maintain, troubleshoot, and repair cameras and monitors &nbsp;<\/li><li>Must be able to troubleshoot, adjust and maintain PLC\u2019s<\/li><li>Must be able to troubleshoot, calibrate and maintain belt-weighing devices, pressure-sensing devises, temperature-sensing devices, motion[1]sensing devices, flow meters, flow control valves, and level indicators.<\/li><li>Ensures maintenance tools are kept in good condition, repaired, replaced when necessary<\/li><li>Must possess and maintain a complete set of personal hand tools as per the LNA tool list<\/li><li>Must perform post-job inspection to ensure a high level of housekeeping standards<\/li><li>Must be able to operate small mobile equipment<\/li><li>Must be willing to upgrade skills by participating in vendor training<\/li><li>Must be willing to upgrade level of skills by participating in company designated training<\/li><li>Must be willing to train on any new equipment installations<\/li><li>Must be willing to perform any other assigned tasks not specifically indicated<\/li><li>Perform other duties as assigned<\/li><\/ul>\n<p><\/p>\n<p><strong>ATTRIBUTES: <\/strong><\/p>\n<ul><li>Must be capable of working any shift, overtime, be on-call, or work seven days a week, if needed.<\/li><li>Must be able to multi-task with a strong sense of urgency to meet the customer needs.<\/li><li>Must be able to work well within a team environment and take instructions from management and co-workers.<\/li><li>Must be able to effectively communicate and interact with supervisors and peers.<\/li><li>Must be a self-starter with the ability to work independently.<\/li><li>Must possess the basic reading and math skills.<\/li><li>Must have good written and verbal communication skills.<\/li><li>Must be able to read, white, and perform basic mathematical calculations.&nbsp;<\/li><li>Must have a valid driver\u2019s license.<\/li><li>Must be capable of operating loaders, skid steer, and manlift as required.<\/li><li>Strong record of attendance reliability.<\/li><li>Must know, understand, and observe all department and plant safety rules and maintain a high level of housekeeping in assigned work areas.<\/li><li>Must be capable of performing the essential job duties required of this job<\/li><li>Must possess basic computer skills on how to use MS Office products and SAP<\/li><\/ul>\n<p><\/p>\n<p><strong>Physical Demands include, but are not limited to: <\/strong><\/p>\n<ul><li>Must be physically able to perform work assigned.<\/li><li>Must be physically capable of accessing all plant locations.<\/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>Will be working at times in covered environment but mainly in a lime\/mineral environment.<\/li><li>The employee will be exposed to the following working conditions: Extreme Heat and Cold, Noise, Vibration, Oils, and Atmospheric Conditions such as Dust, Fumes, and Lime\/Mineral Particles.<\/li><li>The employee will be required to perform the following actions (from time to time): Standing, walking, balancing, stooping, kneeling, reaching, talking, seeing, hearing and sitting.<\/li><li>Ability to lift up to 50 pounds<\/li><\/ul>\n<p><\/p>\n<p><strong>Required Experience:&nbsp; <\/strong>3-5 years electrical experience. Completion of an apprenticeship program, technical program, or equivalent experience in industrial background<\/p>\n<p><\/p>\n<p><strong>Required Education:&nbsp; <\/strong>High School Diploma or GED equivalent. Completion of an apprenticeship program, technical program, or equivalent experience in industrial background<\/p>","post_title":"Industrial Electrician","post_link":"https:\/\/turnerstaffing.com\/position\/industrial-electrician-2\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Mid Level","%location_country%":"United States","%location_city%":"Sherwood","%location_state_id%":"TN","%location_state_name%":"Tennessee","%location_city_state%":"Sherwood, TN","%education%":"High School or equivalent","%department%":"","%description%":"<p><strong>POSITION SUMMARY:&nbsp; &nbsp;<\/strong>To perform electrical and instrumentation inspections, repairs and rebuilds on all plant operating equipment to ensure continuous operation within the required quality control standards. This role is critical to achieving Plant OEE and Equipment Availability goals by elimination of unplanned stops and extended downtimes. Incumbents in the position are required to participate in company-sponsored training and certification programs to ensure that their job knowledge and skills meet evolving company standards.<\/p>\n<p><\/p>\n<p><strong>RESPONSIBILITIES &amp; EXPECTATIONS: <\/strong><\/p>\n<ul><li>Must comply with company, state and governmental health and safety regulations at all times<\/li><\/ul>\n<ul><li>Must complete and document Workplace Inspections in a timely manner<\/li><li>Must be able to perform preventive maintenance checks and report findings (both verbally and in writing)<\/li><li>Must participate in the work order initiation process when required<\/li><li>Must ensure all inventory parts are correctly charged through work orders as per LNA procedures<\/li><li>Must possess a good knowledge of power distribution systems<\/li><li>Must be well versed in the installation, maintenance, and adjustment of transformers, motors, switches etc.<\/li><li>Must be able to perform low voltage and medium voltage terminations<\/li><li>Must be capable of performing maintenance on switchgear up to 480 volts<\/li><li>Must be capable of troubleshooting and maintaining all types of starters, vfd\u2019s etc.<\/li><li>Must be able to perform basic electrical calculations<\/li><li>Must be able to perform tasks with all electrical test equipment (volt meters, meggers, current generators, loop calibrators, etc)<\/li><li>Must be able to fabricate and install conduit<\/li><li>Must be able to perform soldering operations<\/li><li>Must be able to install and align electrical motors<\/li><li>Must be able to troubleshoot and maintain motor control circuits and air dryers<\/li><li>Must be able to maintain and replace control valves, actuators, and positioners &nbsp;<\/li><li>Must be proficient in the use of precision measuring tools (micrometers, dial indicators, etc)<\/li><li>Should possess some knowledge of the CMMS System and be willing to navigate the software correctly.<\/li><li>Must be familiar with thermography and fully understand the uses<\/li><li>Must be able to troubleshoot and perform repairs to hydraulic\/pneumatics systems<\/li><li>Must be able to maintain, troubleshoot, and repair cameras and monitors &nbsp;<\/li><li>Must be able to troubleshoot, adjust and maintain PLC\u2019s<\/li><li>Must be able to troubleshoot, calibrate and maintain belt-weighing devices, pressure-sensing devises, temperature-sensing devices, motion[1]sensing devices, flow meters, flow control valves, and level indicators.<\/li><li>Ensures maintenance tools are kept in good condition, repaired, replaced when necessary<\/li><li>Must possess and maintain a complete set of personal hand tools as per the LNA tool list<\/li><li>Must perform post-job inspection to ensure a high level of housekeeping standards<\/li><li>Must be able to operate small mobile equipment<\/li><li>Must be willing to upgrade skills by participating in vendor training<\/li><li>Must be willing to upgrade level of skills by participating in company designated training<\/li><li>Must be willing to train on any new equipment installations<\/li><li>Must be willing to perform any other assigned tasks not specifically indicated<\/li><li>Perform other duties as assigned<\/li><\/ul>\n<p><\/p>\n<p><strong>ATTRIBUTES: <\/strong><\/p>\n<ul><li>Must be capable of working any shift, overtime, be on-call, or work seven days a week, if needed.<\/li><li>Must be able to multi-task with a strong sense of urgency to meet the customer needs.<\/li><li>Must be able to work well within a team environment and take instructions from management and co-workers.<\/li><li>Must be able to effectively communicate and interact with supervisors and peers.<\/li><li>Must be a self-starter with the ability to work independently.<\/li><li>Must possess the basic reading and math skills.<\/li><li>Must have good written and verbal communication skills.<\/li><li>Must be able to read, white, and perform basic mathematical calculations.&nbsp;<\/li><li>Must have a valid driver\u2019s license.<\/li><li>Must be capable of operating loaders, skid steer, and manlift as required.<\/li><li>Strong record of attendance reliability.<\/li><li>Must know, understand, and observe all department and plant safety rules and maintain a high level of housekeeping in assigned work areas.<\/li><li>Must be capable of performing the essential job duties required of this job<\/li><li>Must possess basic computer skills on how to use MS Office products and SAP<\/li><\/ul>\n<p><\/p>\n<p><strong>Physical Demands include, but are not limited to: <\/strong><\/p>\n<ul><li>Must be physically able to perform work assigned.<\/li><li>Must be physically capable of accessing all plant locations.<\/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>Will be working at times in covered environment but mainly in a lime\/mineral environment.<\/li><li>The employee will be exposed to the following working conditions: Extreme Heat and Cold, Noise, Vibration, Oils, and Atmospheric Conditions such as Dust, Fumes, and Lime\/Mineral Particles.<\/li><li>The employee will be required to perform the following actions (from time to time): Standing, walking, balancing, stooping, kneeling, reaching, talking, seeing, hearing and sitting.<\/li><li>Ability to lift up to 50 pounds<\/li><\/ul>\n<p><\/p>\n<p><strong>Required Experience:&nbsp; <\/strong>3-5 years electrical experience. Completion of an apprenticeship program, technical program, or equivalent experience in industrial background<\/p>\n<p><\/p>\n<p><strong>Required Education:&nbsp; <\/strong>High School Diploma or GED equivalent. Completion of an apprenticeship program, technical program, or equivalent experience in industrial background<\/p>","%category%":"Other","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/412a0758b41e-industrial-electrician","%breezy_id%":"412a0758b41e","%breezy_friendly_id%":"412a0758b41e-industrial-electrician","%breezy_created_date%":"2025-02-07T01:21:06.085Z","%breezy_updated_date%":"2026-01-14T19:18:11.050Z","%_wpgmp_location_city%":"Sherwood","%_wpgmp_location_state%":"TN","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Sherwood, TN, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"35.0761938","%_wpgmp_metabox_longitude%":"-85.9233121","%rank_math_internal_links_processed%":"1"}},"id":2951,"infowindow_disable":false},{"source":"post","title":"Mine Office Administrator","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Mine Office Administrator\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Job Description: Mine Office Administrator Company: Turner Mining Group Location: Soda Springs, Idaho Reports to: General Plant Manager Job Summary:&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/mine-office-administrator\/\" name=\"Mine Office Administrator\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Job Description: Mine Office Administrator Company: Turner Mining Group Location: Soda Springs, Idaho Reports to: General Plant Manager Job Summary:&hellip;","address":"Soda Springs, ID, USA","location":{"lat":"42.6543652","city":"Soda Springs","state":"ID","country":"United States","lng":"-111.6046687","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/mine-office-administrator\/","zoom":19,"extra_fields":{"post_excerpt":"Job Description: Mine Office Administrator Company: Turner Mining Group Location: Soda Springs, Idaho Reports to: General Plant Manager Job Summary:&hellip;","post_content":"<h3><strong>Job Description: Mine Office Administrator<\/strong><\/h3>\n<p><strong>Company:<\/strong> Turner Mining Group\n<br><strong>Location:<\/strong> Soda Springs, Idaho\n<br><strong>Reports to:<\/strong> General Plant Manager<\/p>\n<p><strong>Job Summary:<\/strong><\/p>\n<p>Turner Mining Group is seeking a highly organized and detail-oriented Mine Office Administrator to join our team in Soda Springs, Idaho. The ideal candidate will be a proactive problem-solver with excellent communication skills, responsible for managing all administrative functions of the mine office and ensuring efficient operations. This role is essential for coordinating communication, managing documentation, and providing critical support to plant management and various departments.<\/p>\n<p><strong>Areas of Responsibility:<\/strong><\/p>\n<ul><li>Coordinate and maintain effective office procedures and efficient workflow.<\/li><li>Implement Corporate and plant-specific policies and procedures.<\/li><li>Coordinate and direct incoming and outgoing mail and courier services.<\/li><li>Maintain appropriate records and manage them according to policy.<\/li><li>Periodically archive or purge files according to the Records Retention Policy and Procedure.<\/li><li>Function as the primary contact for customers calling the plant and take orders as required.<\/li><li>Serve as liaison with Corporate Customer Service to provide customers with needed support and processing of orders.<\/li><li>Plan and schedule truck, prepare shipping documents, and maintain records of all products and customer purchase orders.<\/li><li>Work with the Plant Operations Manager and Production &amp; Shipping Supervisors to establish loadout and shipment schedules.<\/li><li>Compile daily, weekly, monthly, and annual reports of shipments and production.<\/li><li>Maintain customer shipment files, including customer profile information.<\/li><li>Coordinate material sample requests to ensure timely receipt by requisitioner.<\/li><li>Prepare and transmit invoices to Finance.<\/li><li>Handle inquiries from vendors and contractors regarding accounts payable.<\/li><li>Select and\/or make recommendations for purchase of office supplies and equipment.<\/li><li>And other duties as assigned.<\/li><\/ul>\n<p><u><strong>Benefits<\/strong><\/u><br>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. 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":"Mine Office Administrator","post_link":"https:\/\/turnerstaffing.com\/position\/mine-office-administrator\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Associate","%location_country%":"United States","%location_city%":"Soda Springs","%location_state_id%":"ID","%location_state_name%":"Idaho","%location_city_state%":"Soda Springs, ID","%education%":"Unspecified","%department%":"Administration","%description%":"<h3><strong>Job Description: Mine Office Administrator<\/strong><\/h3>\n<p><strong>Company:<\/strong> Turner Mining Group\n<br><strong>Location:<\/strong> Soda Springs, Idaho\n<br><strong>Reports to:<\/strong> General Plant Manager<\/p>\n<p><strong>Job Summary:<\/strong><\/p>\n<p>Turner Mining Group is seeking a highly organized and detail-oriented Mine Office Administrator to join our team in Soda Springs, Idaho. The ideal candidate will be a proactive problem-solver with excellent communication skills, responsible for managing all administrative functions of the mine office and ensuring efficient operations. This role is essential for coordinating communication, managing documentation, and providing critical support to plant management and various departments.<\/p>\n<p><strong>Areas of Responsibility:<\/strong><\/p>\n<ul><li>Coordinate and maintain effective office procedures and efficient workflow.<\/li><li>Implement Corporate and plant-specific policies and procedures.<\/li><li>Coordinate and direct incoming and outgoing mail and courier services.<\/li><li>Maintain appropriate records and manage them according to policy.<\/li><li>Periodically archive or purge files according to the Records Retention Policy and Procedure.<\/li><li>Function as the primary contact for customers calling the plant and take orders as required.<\/li><li>Serve as liaison with Corporate Customer Service to provide customers with needed support and processing of orders.<\/li><li>Plan and schedule truck, prepare shipping documents, and maintain records of all products and customer purchase orders.<\/li><li>Work with the Plant Operations Manager and Production &amp; Shipping Supervisors to establish loadout and shipment schedules.<\/li><li>Compile daily, weekly, monthly, and annual reports of shipments and production.<\/li><li>Maintain customer shipment files, including customer profile information.<\/li><li>Coordinate material sample requests to ensure timely receipt by requisitioner.<\/li><li>Prepare and transmit invoices to Finance.<\/li><li>Handle inquiries from vendors and contractors regarding accounts payable.<\/li><li>Select and\/or make recommendations for purchase of office supplies and equipment.<\/li><li>And other duties as assigned.<\/li><\/ul>\n<p><u><strong>Benefits<\/strong><\/u><br>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. 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\/0113edbc5aaa-mine-office-administrator","%breezy_id%":"0113edbc5aaa","%breezy_friendly_id%":"0113edbc5aaa-mine-office-administrator","%breezy_created_date%":"2025-11-21T17:58:34.313Z","%breezy_updated_date%":"2025-11-21T17:58:58.625Z","%_wpgmp_location_city%":"Soda Springs","%_wpgmp_location_state%":"ID","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Soda Springs, ID, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"42.6543652","%_wpgmp_metabox_longitude%":"-111.6046687","%rank_math_internal_links_processed%":"1"}},"id":2927,"infowindow_disable":false},{"source":"post","title":"Field Electrical Engineer","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Field Electrical Engineer\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    This role is accountable for delivering technical support related to routine and moderately complex maintenance, troubleshooting, and repair of control&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/field-electrical-engineer\/\" name=\"Field Electrical Engineer\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"This role is accountable for delivering technical support related to routine and moderately complex maintenance, troubleshooting, and repair of control&hellip;","address":"Virginia, MN, USA","location":{"lat":"47.5232596","city":"Virginia","state":"MN","country":"United States","lng":"-92.5365713","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/field-electrical-engineer\/","zoom":19,"extra_fields":{"post_excerpt":"This role is accountable for delivering technical support related to routine and moderately complex maintenance, troubleshooting, and repair of control&hellip;","post_content":"<p>This role is accountable for delivering technical support related to routine and moderately complex maintenance, troubleshooting, and repair of control systems and associated components at customer locations or designated service facilities.<\/p>\n<p><strong>Key Responsibilities :<\/strong><\/p>\n<ul>\n<li>\n<p>Deliver field-based engineering and technical support services for customer operations.<\/p>\n<\/li>\n<li>\n<p>Troubleshoot and diagnose problems involving control systems and related components at customer sites or service shops.<\/p>\n<\/li>\n<li>\n<p>Document service activities, including time, expenses, and job details, with accuracy and completeness.<\/p>\n<\/li>\n<li>\n<p>Coordinate work by communicating with supervisors, shop managers, and office staff to ensure alignment across assigned projects.<\/p>\n<\/li>\n<li>\n<p>Prioritize and schedule tasks to meet project deadlines and customer expectations.<\/p>\n<\/li>\n<li>\n<p>Prepare quotations for assigned work scopes, or oversee their preparation when needed.<\/p>\n<\/li>\n<li>\n<p>Provide guidance or hands-on training to team members or customer personnel as required.<\/p>\n<\/li>\n<li>\n<p>Ensure all necessary tools, test equipment, and materials are available and in proper working condition to perform tasks efficiently.<\/p>\n<\/li>\n<li>\n<p>Offer after-hours technical support both in person and over the phone when necessary.<\/p>\n<\/li>\n<li>\n<p>Follow all applicable safety procedures and utilize appropriate protective equipment at all times.<\/p>\n<\/li>\n<\/ul>\n<p><strong>Additional Requirement:<\/strong><\/p>\n<ul>\n<li>\n<p>Overnight travel is required.<br><br><\/p><p>\u00b7         Bachelor of Science or equivalent practical experience.<\/p>\n<p>\u00b7&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; Relevant manufacturer product training.<\/p>\n<p>\u00b7&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; Minimum 4- 5 years\u2019 experience in related field in mining, metal, mills and\/or heavy industry. PLC and Drive experience required.<\/p>\n<p><\/p>\n<p>Valid Driver License Required<\/p><p><\/p><\/li><\/ul>","post_title":"Field Electrical Engineer","post_link":"https:\/\/turnerstaffing.com\/position\/field-electrical-engineer\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"","%location_country%":"United States","%location_city%":"Virginia","%location_state_id%":"MN","%location_state_name%":"Minnesota","%location_city_state%":"Virginia, MN","%education%":"","%department%":"","%description%":"<p>This role is accountable for delivering technical support related to routine and moderately complex maintenance, troubleshooting, and repair of control systems and associated components at customer locations or designated service facilities.<\/p>\n<p><strong>Key Responsibilities :<\/strong><\/p>\n<ul>\n<li>\n<p>Deliver field-based engineering and technical support services for customer operations.<\/p>\n<\/li>\n<li>\n<p>Troubleshoot and diagnose problems involving control systems and related components at customer sites or service shops.<\/p>\n<\/li>\n<li>\n<p>Document service activities, including time, expenses, and job details, with accuracy and completeness.<\/p>\n<\/li>\n<li>\n<p>Coordinate work by communicating with supervisors, shop managers, and office staff to ensure alignment across assigned projects.<\/p>\n<\/li>\n<li>\n<p>Prioritize and schedule tasks to meet project deadlines and customer expectations.<\/p>\n<\/li>\n<li>\n<p>Prepare quotations for assigned work scopes, or oversee their preparation when needed.<\/p>\n<\/li>\n<li>\n<p>Provide guidance or hands-on training to team members or customer personnel as required.<\/p>\n<\/li>\n<li>\n<p>Ensure all necessary tools, test equipment, and materials are available and in proper working condition to perform tasks efficiently.<\/p>\n<\/li>\n<li>\n<p>Offer after-hours technical support both in person and over the phone when necessary.<\/p>\n<\/li>\n<li>\n<p>Follow all applicable safety procedures and utilize appropriate protective equipment at all times.<\/p>\n<\/li>\n<\/ul>\n<p><strong>Additional Requirement:<\/strong><\/p>\n<ul>\n<li>\n<p>Overnight travel is required.<br><br><\/p><p>\u00b7         Bachelor of Science or equivalent practical experience.<\/p>\n<p>\u00b7&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; Relevant manufacturer product training.<\/p>\n<p>\u00b7&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; Minimum 4- 5 years\u2019 experience in related field in mining, metal, mills and\/or heavy industry. PLC and Drive experience required.<\/p>\n<p><\/p>\n<p>Valid Driver License Required<\/p><p><\/p><\/li><\/ul>","%category%":"Operations","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/ed128d468e61-field-electrical-engineer","%breezy_id%":"ed128d468e61","%breezy_friendly_id%":"ed128d468e61-field-electrical-engineer","%breezy_created_date%":"2025-11-21T20:01:14.673Z","%breezy_updated_date%":"2025-12-09T13:23:43.978Z","%_wpgmp_location_city%":"Virginia","%_wpgmp_location_state%":"MN","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Virginia, MN, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"47.5232596","%_wpgmp_metabox_longitude%":"-92.5365713","%rank_math_internal_links_processed%":"1"}},"id":2929,"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    To perform electrical and instrumentation inspections, repairs and rebuilds on all plant operating equipment to ensure continuous operation within the&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":"To perform electrical and instrumentation inspections, repairs and rebuilds on all plant operating equipment to ensure continuous operation within the&hellip;","address":"Peach Springs, AZ, USA","location":{"lat":"35.5291589","city":"Peach Springs","state":"AZ","country":"United States","lng":"-113.425491","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/industrial-electrician\/","zoom":19,"extra_fields":{"post_excerpt":"To perform electrical and instrumentation inspections, repairs and rebuilds on all plant operating equipment to ensure continuous operation within the&hellip;","post_content":"<p> To perform electrical and instrumentation inspections, repairs and rebuilds on all plant operating equipment to ensure continuous operation within the required quality control standards. This role is critical to achieving Plant OEE and Equipment Availability goals by elimination of unplanned stops and extended downtimes. Incumbents in the position are required to participate in company-sponsored training and certification programs to ensure that their job knowledge and skills meet evolving company standards.<\/p>\n<p><\/p>\n<p><strong>RESPONSIBILITIES &amp; EXPECTATIONS:<\/strong><\/p>\n<ul><li>Must comply with company, state and governmental health and safety regulations at all times<\/li><li>Must complete and document Workplace Inspections in a timely manner<\/li><li>Must be able to perform preventive maintenance checks and report findings (both verbally and in writing)<\/li><li>Must participate in the work order initiation process when required<\/li><li>Must ensure all inventory parts are correctly charged from Stores as per LNA procedures<\/li><li>Must possess a good knowledge of power distribution systems<\/li><li>Must be well versed in the installation, maintenance, and adjustment of transformers<\/li><li>Must be able to perform low voltage and high voltage terminations<\/li><li>Must be capable of performing maintenance on switchgear up to 4160 volts.<\/li><li>Must have knowledge of low, medium and high voltage switching applications.<\/li><li>Must have experience with Windows OS and Microsoft Office programs. AutoCAD and SAP experience preferred but not required.<\/li><li>Must be capable of troubleshooting and maintaining all types of motor control circuits.<\/li><li>Must be able to:<p><\/p><ul><li>Perform basic electrical calculations<\/li><li>Perform tasks with all electrical test equipment (volt meters, meggers, current generators, loop calibrators, etc)<\/li><li>Fabricate and install conduit<\/li><li>Perform soldering operations<\/li><li>Test, troubleshoot and repair AC\/DC motors and drives<\/li><li>Install and align electrical motors<\/li><li>Troubleshoot and maintain air dryers<\/li><li>Calibrate, troubleshoot and maintain belt-weighing devices<\/li><li>Maintain and replace process control circuits including control valves, actuators and positioners<\/li><\/ul><\/li><li>Must be proficient in the use of precision measuring tools (multimeters, meggors, 0 to 10 VDC, 4 to 20 mA circuit drivers and testing etc.)<\/li><li>Should possess some knowledge of the CMMS System and be willing to correctly complete work orders and checklist including signing and dating<\/li><li>Must be familiar with thermography and fully understand the uses<\/li><li>Must be able to:<p><\/p><ul><li>Troubleshoot and perform repairs to hydraulic\/pneumatics systems<\/li><li>Perform troubleshooting and repairs on Gas Analyzers<\/li><li>Troubleshoot and modify control loops<\/li><li>Maintain, troubleshoot, and repair cameras and monitors<\/li><\/ul><\/li><\/ul>\n<p><\/p>\n<p><strong>Safe Quality Food (SQF)<\/strong><\/p>\n<ul><li>Ensure a SQF workplace and follow regulatory compliance with Federal FDA \u2013 Food Modernization Safety Act (CFR Code of Federal Regulations Title 21, Part 507).<\/li><li>Support Environmental Health and Safety, as well as SQF initiatives and awareness programs.<\/li><li>Be a leader and promoter of employee safety and SQF culture.<\/li><li>Following completion of SQF training, demonstrate understanding of expected safety, SQF performance and Food Safety Culture.<\/li><li>Complete periodic SQF training(s).<\/li><li>Each site location will ensure training is conducted for new employees and continued for existing employees.<\/li><li>Employees will actively participate in audits for regulatory, safety, SQF and environmental compliance at the site.<\/li><\/ul>\n<p><\/p>\n<p><strong>ATTRIBUTES:<\/strong><\/p>\n<ul><li>Must be capable of working any shift, overtime, be on-call, or work seven days a week, if needed.<\/li><li>Must be able to multi task with a strong sense of urgency to meet the customer needs.<\/li><li>Must be able to work well within a team environment and take instructions from management and co-workers.&nbsp;<\/li><li>Must be a self-starter with the ability to work independently.<\/li><li>Must possess the basic reading and math skills.<\/li><li>Must have good written and verbal communication skills.<\/li><li>Must possess basic computer skills on how to use MS Office products and SAP.<\/li><li>Strong record of attendance reliability.<\/li><li>Must know, understand and observe all department and plant safety rules and maintain a high level of housekeeping in assigned work areas.<\/li><li>Must be capable of performing the essential job duties required of this job.<\/li><\/ul>\n<p><\/p>\n<p><\/p>\n<p><strong>PHYSICAL DEMANDS INCLUDE, BUT ARE NOT LIMITED TO:&nbsp;&nbsp;<\/strong><strong><\/strong>&nbsp;<\/p>\n<ul><li>Must be physically able to perform work assigned.<\/li><li>Must be physically capable of accessing all plant locations.<\/li><li>Access all areas within a site which could include heights of 150 feet, confined spaces, climbing ladders or stairs, and accessing tunnels.<\/li><li>Will be working at times in covered environment but mainly in a lime\/mineral environment.<\/li><li>The employee will be exposed to the following working conditions: Extreme Heat and Cold, Noise, Vibration, Oils, and Atmospheric Conditions such as Dust, Fumes, and Lime\/Mineral Particles.<\/li><li>The employee will be required to perform the following actions (from time to time): Standing, walking, balancing, stooping, kneeling, reaching, talking, seeing, hearing and sitting.<\/li><li>Ability to lift\/carry up to 50 pounds.<\/li><\/ul>\n<p><\/p>\n<p><strong>REQUIRED EDUCATION:<\/strong><\/p>\n<ul><li>&nbsp;High School Diploma or GED equivalent<\/li><li>Current Journeyman License<\/li><\/ul>\n<p><strong>PREFERRED EDUCATION: <\/strong><\/p>\n<ul><li>Associate's degree or Certificate in industrial electrical technology a plus<\/li><\/ul>\n<p><\/p>\n<p><strong>REQUIRED EXPERIENCE:<\/strong><\/p>\n<ul><li>&nbsp;5 to 7 years electrical experience<\/li><li>Completion of an apprenticeship program, technical program, or equivalent experience in industrial background<\/li><\/ul>\n<p><strong>PREFFERED EXPERIENCE:<\/strong><\/p>\n<ul><li>&nbsp;Previous heavy manufacturing and\/or mining experience is highly preferred<\/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%":"Peach Springs","%location_state_id%":"AZ","%location_state_name%":"Arizona","%location_city_state%":"Peach Springs, AZ","%education%":"High School or equivalent","%department%":"","%description%":"<p> To perform electrical and instrumentation inspections, repairs and rebuilds on all plant operating equipment to ensure continuous operation within the required quality control standards. This role is critical to achieving Plant OEE and Equipment Availability goals by elimination of unplanned stops and extended downtimes. Incumbents in the position are required to participate in company-sponsored training and certification programs to ensure that their job knowledge and skills meet evolving company standards.<\/p>\n<p><\/p>\n<p><strong>RESPONSIBILITIES &amp; EXPECTATIONS:<\/strong><\/p>\n<ul><li>Must comply with company, state and governmental health and safety regulations at all times<\/li><li>Must complete and document Workplace Inspections in a timely manner<\/li><li>Must be able to perform preventive maintenance checks and report findings (both verbally and in writing)<\/li><li>Must participate in the work order initiation process when required<\/li><li>Must ensure all inventory parts are correctly charged from Stores as per LNA procedures<\/li><li>Must possess a good knowledge of power distribution systems<\/li><li>Must be well versed in the installation, maintenance, and adjustment of transformers<\/li><li>Must be able to perform low voltage and high voltage terminations<\/li><li>Must be capable of performing maintenance on switchgear up to 4160 volts.<\/li><li>Must have knowledge of low, medium and high voltage switching applications.<\/li><li>Must have experience with Windows OS and Microsoft Office programs. AutoCAD and SAP experience preferred but not required.<\/li><li>Must be capable of troubleshooting and maintaining all types of motor control circuits.<\/li><li>Must be able to:<p><\/p><ul><li>Perform basic electrical calculations<\/li><li>Perform tasks with all electrical test equipment (volt meters, meggers, current generators, loop calibrators, etc)<\/li><li>Fabricate and install conduit<\/li><li>Perform soldering operations<\/li><li>Test, troubleshoot and repair AC\/DC motors and drives<\/li><li>Install and align electrical motors<\/li><li>Troubleshoot and maintain air dryers<\/li><li>Calibrate, troubleshoot and maintain belt-weighing devices<\/li><li>Maintain and replace process control circuits including control valves, actuators and positioners<\/li><\/ul><\/li><li>Must be proficient in the use of precision measuring tools (multimeters, meggors, 0 to 10 VDC, 4 to 20 mA circuit drivers and testing etc.)<\/li><li>Should possess some knowledge of the CMMS System and be willing to correctly complete work orders and checklist including signing and dating<\/li><li>Must be familiar with thermography and fully understand the uses<\/li><li>Must be able to:<p><\/p><ul><li>Troubleshoot and perform repairs to hydraulic\/pneumatics systems<\/li><li>Perform troubleshooting and repairs on Gas Analyzers<\/li><li>Troubleshoot and modify control loops<\/li><li>Maintain, troubleshoot, and repair cameras and monitors<\/li><\/ul><\/li><\/ul>\n<p><\/p>\n<p><strong>Safe Quality Food (SQF)<\/strong><\/p>\n<ul><li>Ensure a SQF workplace and follow regulatory compliance with Federal FDA \u2013 Food Modernization Safety Act (CFR Code of Federal Regulations Title 21, Part 507).<\/li><li>Support Environmental Health and Safety, as well as SQF initiatives and awareness programs.<\/li><li>Be a leader and promoter of employee safety and SQF culture.<\/li><li>Following completion of SQF training, demonstrate understanding of expected safety, SQF performance and Food Safety Culture.<\/li><li>Complete periodic SQF training(s).<\/li><li>Each site location will ensure training is conducted for new employees and continued for existing employees.<\/li><li>Employees will actively participate in audits for regulatory, safety, SQF and environmental compliance at the site.<\/li><\/ul>\n<p><\/p>\n<p><strong>ATTRIBUTES:<\/strong><\/p>\n<ul><li>Must be capable of working any shift, overtime, be on-call, or work seven days a week, if needed.<\/li><li>Must be able to multi task with a strong sense of urgency to meet the customer needs.<\/li><li>Must be able to work well within a team environment and take instructions from management and co-workers.&nbsp;<\/li><li>Must be a self-starter with the ability to work independently.<\/li><li>Must possess the basic reading and math skills.<\/li><li>Must have good written and verbal communication skills.<\/li><li>Must possess basic computer skills on how to use MS Office products and SAP.<\/li><li>Strong record of attendance reliability.<\/li><li>Must know, understand and observe all department and plant safety rules and maintain a high level of housekeeping in assigned work areas.<\/li><li>Must be capable of performing the essential job duties required of this job.<\/li><\/ul>\n<p><\/p>\n<p><\/p>\n<p><strong>PHYSICAL DEMANDS INCLUDE, BUT ARE NOT LIMITED TO:&nbsp;&nbsp;<\/strong><strong><\/strong>&nbsp;<\/p>\n<ul><li>Must be physically able to perform work assigned.<\/li><li>Must be physically capable of accessing all plant locations.<\/li><li>Access all areas within a site which could include heights of 150 feet, confined spaces, climbing ladders or stairs, and accessing tunnels.<\/li><li>Will be working at times in covered environment but mainly in a lime\/mineral environment.<\/li><li>The employee will be exposed to the following working conditions: Extreme Heat and Cold, Noise, Vibration, Oils, and Atmospheric Conditions such as Dust, Fumes, and Lime\/Mineral Particles.<\/li><li>The employee will be required to perform the following actions (from time to time): Standing, walking, balancing, stooping, kneeling, reaching, talking, seeing, hearing and sitting.<\/li><li>Ability to lift\/carry up to 50 pounds.<\/li><\/ul>\n<p><\/p>\n<p><strong>REQUIRED EDUCATION:<\/strong><\/p>\n<ul><li>&nbsp;High School Diploma or GED equivalent<\/li><li>Current Journeyman License<\/li><\/ul>\n<p><strong>PREFERRED EDUCATION: <\/strong><\/p>\n<ul><li>Associate's degree or Certificate in industrial electrical technology a plus<\/li><\/ul>\n<p><\/p>\n<p><strong>REQUIRED EXPERIENCE:<\/strong><\/p>\n<ul><li>&nbsp;5 to 7 years electrical experience<\/li><li>Completion of an apprenticeship program, technical program, or equivalent experience in industrial background<\/li><\/ul>\n<p><strong>PREFFERED EXPERIENCE:<\/strong><\/p>\n<ul><li>&nbsp;Previous heavy manufacturing and\/or mining experience is highly preferred<\/li><\/ul>","%category%":"Other","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/e7981bb22a7b-industrial-electrician","%breezy_id%":"e7981bb22a7b","%breezy_friendly_id%":"e7981bb22a7b-industrial-electrician","%breezy_created_date%":"2025-02-07T00:48:51.622Z","%breezy_updated_date%":"2026-01-14T19:18:10.056Z","%_wpgmp_location_city%":"Peach Springs","%_wpgmp_location_state%":"AZ","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Peach Springs, AZ, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"35.5291589","%_wpgmp_metabox_longitude%":"-113.425491","%rank_math_internal_links_processed%":"1"}},"id":2926,"infowindow_disable":false},{"source":"post","title":"Senior Equipment Operator","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Senior Equipment Operator\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Senior Equipment Operator &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; Reports to: Foreman \u2013 Turner Mining Group Job Description: The Senior Equipment Operator is the most&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/senior-equipment-operator\/\" name=\"Senior Equipment Operator\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Senior Equipment Operator &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; Reports to: Foreman \u2013 Turner Mining Group Job Description: The Senior Equipment Operator is the most&hellip;","address":"Soda Springs, ID, USA","location":{"lat":"42.6543652","city":"Soda Springs","state":"ID","country":"United States","lng":"-111.6046687","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/senior-equipment-operator\/","zoom":19,"extra_fields":{"post_excerpt":"Senior Equipment Operator &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; Reports to: Foreman \u2013 Turner Mining Group Job Description: The Senior Equipment Operator is the most&hellip;","post_content":"<p><strong>Senior Equipment Operator<\/strong>                    &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; <\/p>\n<p><strong>Reports to: <\/strong><strong>Foreman \u2013 Turner Mining Group<\/strong><\/p>\n<p><strong>Job Description:<\/strong><\/p>\n<p>The Senior Equipment Operator is the most skilled mining operator position within Turner Mining Group. This role will oversee operational quality and efficiency as a strong field leader. The successful candidate must live the Turner Values and be an outward example to others. This position must demonstrate a strong commitment to \u201cSafe Production\u201d through decision making, priorities, and client relations.<\/p>\n<p><strong>Objectives and Contributions:<\/strong><\/p>\n<p>The Senior Equipment Operator is focused on key aspects that drive communication and safe production while maintaining a high level of efficiency, proactive training metrics, and preventative maintenance awareness requirements. The Senior Operator demonstrates safety ownership at a personal level and holds other crew members to the same high standard.&nbsp; The Senior Equipment Operator will train and develop into the Lead Equipment Operator job scope while the Lead Equipment operator is filling in for supervisory duties. <\/p>\n<ul><li>Operates mobile equipment as assigned every day based on production needs<\/li><li>Work with employees to ensure a high level of accuracy and engagement on hazard identification and control<\/li><li>Engage crews and leadership to define processes that motivate working towards common goals<\/li><li>Assist with MSHA regulatory training and verify compliance to standards<\/li><li>Live the values as part of a visible daily decision-making process<\/li><li>Assist with training efforts to grow other operators<\/li><li>Assist with training proficiency audits<\/li><li>Assist with client specific safety needs as required<\/li><li>Support risk assessment processes at various levels of the organization<\/li><li>Holds themselves and others accountable for acting like an owner (taking care of equipment, not wasting resources, using time wisely, and being accountable for conditions and behaviors)<\/li><li>Maintains a high standard of housekeeping (machine and work areas)<\/li><\/ul>\n<p><u>Culture and Communication:<\/u><\/p>\n<ul><li>Can effectively communicate in English (multi-lingual preferred)<\/li><li>Assist with daily lineout meetings and monthly safety topic communications<\/li><li>Assist with site communication programs and processes to ensure timely, specific, and value-added information<\/li><li>Assist with site and project leaders to identify areas of improvement<\/li><li>Work with crews to support proactive near miss reporting<\/li><li>Leads by example (walks the talk)<\/li><\/ul>\n<p><u>Systems:<\/u><\/p>\n<ul><li>Ability to perform quality pre-operation machine inspections (Based on mobile equipment physical demands analysis)<\/li><li>Able to perform quality workplace examination (per MSHA requirements)<\/li><li>Ability to use electronic filing and reporting systems<\/li><li>Accurately documents 5000-23 and training checklist requirements<\/li><li>Other regulatory &amp; internal \/ external forms as required<\/li><\/ul>\n<p><u>Travel and New Site Development:<\/u><\/p>\n<ul><li>Maintains a valid and insurable driving license<\/li><li>Available to travel on short notice to support timelines and production requirements at existing sites <strong>(Preferred)<\/strong><\/li><\/ul>\n<p><u>Supervisory \/ Leadership Duties<\/u><\/p>\n<ul><li>Learn and assist with key performance indicators, company targets, and daily progress reporting<\/li><li>Assist in employee timekeeping and production reports<\/li><li>Maintains compliance to Turner Mining Group Policies and Procedures including Fit for Duty requirements<\/li><li>Upholds Code of Conduct requirements<\/li><li>Spend time with maintenance, and site supervision to build relationships and develop trust<\/li><li>Assist with development \/ implement processes to reduce and eliminate repeat incidents<\/li><\/ul>\n<p><u>Time and Interactions:<\/u><\/p>\n<ul><li>The Senior Equipment Operator must be flexible on shift schedules (days and nights) to assist with training and production needs<\/li><li>The Senior Equipment Operator will be self-starting, motivated, with a strong desire to be part of a team and to influence improvement. Communication is also critical to keep leadership and site-based personnel in the loop of successes, challenges, and any additional support that may be required<\/li><li>Interacts with client supervision to discuss production challenges, targets, and collaboration between teams<\/li><li>Excellent time management skills<\/li><\/ul>\n<p><u>Qualifications:<\/u><\/p>\n<ul><li>Smart phone navigation<\/li><li>Willingness and ability to adhere to OSHA \/ MSHA regulatory requirements<\/li><li>3-5 years\u2019 experience in mining \/ heavy industry preferred<\/li><li>Working knowledge of safety systems and processes<\/li><li>Appropriate attention to detail required<\/li><li>Strong communication skills<\/li><li>Strong morals and values<\/li><li>Exemplary attendance record<\/li><li>Exemplary safety and disciplinary record<\/li><li>Willingness to be flexible on daily job duty requirements<\/li><li>Maintains a positive outspoken learning attitude<\/li><li>The Senior Equipment Operator must pass and maintain Turner Mining Group mobile equipment skills qualifications on each piece of the following equipment: <ul><li><strong>Production excavator<\/strong><\/li><li><strong><\/strong><strong>Production loader<\/strong><\/li><li><strong><\/strong><strong>Support excavator<\/strong><\/li><li><strong><\/strong><strong>Dozer<\/strong><\/li><li><strong><\/strong><strong>Support loader<\/strong><\/li><li><strong><\/strong><strong>Grader<\/strong><\/li><li><strong><\/strong><strong>Water truck,<\/strong><\/li><li><strong><\/strong><strong>Haulage truck<\/strong><\/li><\/ul><\/li><\/ul>\n<p><u>Other Duties:<\/u><\/p>\n<ul><li>In addition to the job skills above, there may be requirements for manual tasks to be completed to meet other business needs. Operators in any job duty classification may be required to participate in these additional tasks.<\/li><\/ul>\n<p><u><strong>Benefits<\/strong><\/u><br>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. 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>\n<p><u><br><\/u><\/p>","post_title":"Senior Equipment Operator","post_link":"https:\/\/turnerstaffing.com\/position\/senior-equipment-operator\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Senior","%location_country%":"United States","%location_city%":"Soda Springs","%location_state_id%":"ID","%location_state_name%":"Idaho","%location_city_state%":"Soda Springs, ID","%education%":"Unspecified","%department%":"Operations","%description%":"<p><strong>Senior Equipment Operator<\/strong>                    &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; <\/p>\n<p><strong>Reports to: <\/strong><strong>Foreman \u2013 Turner Mining Group<\/strong><\/p>\n<p><strong>Job Description:<\/strong><\/p>\n<p>The Senior Equipment Operator is the most skilled mining operator position within Turner Mining Group. This role will oversee operational quality and efficiency as a strong field leader. The successful candidate must live the Turner Values and be an outward example to others. This position must demonstrate a strong commitment to \u201cSafe Production\u201d through decision making, priorities, and client relations.<\/p>\n<p><strong>Objectives and Contributions:<\/strong><\/p>\n<p>The Senior Equipment Operator is focused on key aspects that drive communication and safe production while maintaining a high level of efficiency, proactive training metrics, and preventative maintenance awareness requirements. The Senior Operator demonstrates safety ownership at a personal level and holds other crew members to the same high standard.&nbsp; The Senior Equipment Operator will train and develop into the Lead Equipment Operator job scope while the Lead Equipment operator is filling in for supervisory duties. <\/p>\n<ul><li>Operates mobile equipment as assigned every day based on production needs<\/li><li>Work with employees to ensure a high level of accuracy and engagement on hazard identification and control<\/li><li>Engage crews and leadership to define processes that motivate working towards common goals<\/li><li>Assist with MSHA regulatory training and verify compliance to standards<\/li><li>Live the values as part of a visible daily decision-making process<\/li><li>Assist with training efforts to grow other operators<\/li><li>Assist with training proficiency audits<\/li><li>Assist with client specific safety needs as required<\/li><li>Support risk assessment processes at various levels of the organization<\/li><li>Holds themselves and others accountable for acting like an owner (taking care of equipment, not wasting resources, using time wisely, and being accountable for conditions and behaviors)<\/li><li>Maintains a high standard of housekeeping (machine and work areas)<\/li><\/ul>\n<p><u>Culture and Communication:<\/u><\/p>\n<ul><li>Can effectively communicate in English (multi-lingual preferred)<\/li><li>Assist with daily lineout meetings and monthly safety topic communications<\/li><li>Assist with site communication programs and processes to ensure timely, specific, and value-added information<\/li><li>Assist with site and project leaders to identify areas of improvement<\/li><li>Work with crews to support proactive near miss reporting<\/li><li>Leads by example (walks the talk)<\/li><\/ul>\n<p><u>Systems:<\/u><\/p>\n<ul><li>Ability to perform quality pre-operation machine inspections (Based on mobile equipment physical demands analysis)<\/li><li>Able to perform quality workplace examination (per MSHA requirements)<\/li><li>Ability to use electronic filing and reporting systems<\/li><li>Accurately documents 5000-23 and training checklist requirements<\/li><li>Other regulatory &amp; internal \/ external forms as required<\/li><\/ul>\n<p><u>Travel and New Site Development:<\/u><\/p>\n<ul><li>Maintains a valid and insurable driving license<\/li><li>Available to travel on short notice to support timelines and production requirements at existing sites <strong>(Preferred)<\/strong><\/li><\/ul>\n<p><u>Supervisory \/ Leadership Duties<\/u><\/p>\n<ul><li>Learn and assist with key performance indicators, company targets, and daily progress reporting<\/li><li>Assist in employee timekeeping and production reports<\/li><li>Maintains compliance to Turner Mining Group Policies and Procedures including Fit for Duty requirements<\/li><li>Upholds Code of Conduct requirements<\/li><li>Spend time with maintenance, and site supervision to build relationships and develop trust<\/li><li>Assist with development \/ implement processes to reduce and eliminate repeat incidents<\/li><\/ul>\n<p><u>Time and Interactions:<\/u><\/p>\n<ul><li>The Senior Equipment Operator must be flexible on shift schedules (days and nights) to assist with training and production needs<\/li><li>The Senior Equipment Operator will be self-starting, motivated, with a strong desire to be part of a team and to influence improvement. Communication is also critical to keep leadership and site-based personnel in the loop of successes, challenges, and any additional support that may be required<\/li><li>Interacts with client supervision to discuss production challenges, targets, and collaboration between teams<\/li><li>Excellent time management skills<\/li><\/ul>\n<p><u>Qualifications:<\/u><\/p>\n<ul><li>Smart phone navigation<\/li><li>Willingness and ability to adhere to OSHA \/ MSHA regulatory requirements<\/li><li>3-5 years\u2019 experience in mining \/ heavy industry preferred<\/li><li>Working knowledge of safety systems and processes<\/li><li>Appropriate attention to detail required<\/li><li>Strong communication skills<\/li><li>Strong morals and values<\/li><li>Exemplary attendance record<\/li><li>Exemplary safety and disciplinary record<\/li><li>Willingness to be flexible on daily job duty requirements<\/li><li>Maintains a positive outspoken learning attitude<\/li><li>The Senior Equipment Operator must pass and maintain Turner Mining Group mobile equipment skills qualifications on each piece of the following equipment: <ul><li><strong>Production excavator<\/strong><\/li><li><strong><\/strong><strong>Production loader<\/strong><\/li><li><strong><\/strong><strong>Support excavator<\/strong><\/li><li><strong><\/strong><strong>Dozer<\/strong><\/li><li><strong><\/strong><strong>Support loader<\/strong><\/li><li><strong><\/strong><strong>Grader<\/strong><\/li><li><strong><\/strong><strong>Water truck,<\/strong><\/li><li><strong><\/strong><strong>Haulage truck<\/strong><\/li><\/ul><\/li><\/ul>\n<p><u>Other Duties:<\/u><\/p>\n<ul><li>In addition to the job skills above, there may be requirements for manual tasks to be completed to meet other business needs. Operators in any job duty classification may be required to participate in these additional tasks.<\/li><\/ul>\n<p><u><strong>Benefits<\/strong><\/u><br>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. 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>\n<p><u><br><\/u><\/p>","%category%":"Operations","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/6dd6d26f101c-senior-equipment-operator","%breezy_id%":"6dd6d26f101c","%breezy_friendly_id%":"6dd6d26f101c-senior-equipment-operator","%breezy_created_date%":"2025-11-20T21:55:39.248Z","%breezy_updated_date%":"2025-11-20T21:56:07.719Z","%_wpgmp_location_city%":"Soda Springs","%_wpgmp_location_state%":"ID","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Soda Springs, ID, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"42.6543652","%_wpgmp_metabox_longitude%":"-111.6046687","%rank_math_internal_links_processed%":"1"}},"id":2921,"infowindow_disable":false},{"source":"post","title":"Entry Level Miner","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Entry Level Miner\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Entry Level Miner &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; Reports to: Foreman \u2013 Turner Mining Group Job Description: The Entry Level Miner is a starting&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/entry-level-miner\/\" name=\"Entry Level Miner\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Entry Level Miner &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; Reports to: Foreman \u2013 Turner Mining Group Job Description: The Entry Level Miner is a starting&hellip;","address":"Soda Springs, ID, USA","location":{"lat":"42.6543652","city":"Soda Springs","state":"ID","country":"United States","lng":"-111.6046687","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/entry-level-miner\/","zoom":19,"extra_fields":{"post_excerpt":"Entry Level Miner &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; Reports to: Foreman \u2013 Turner Mining Group Job Description: The Entry Level Miner is a starting&hellip;","post_content":"<p><strong>Entry Level Miner<\/strong>                    &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&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><strong>Reports to: <\/strong><strong>Foreman \u2013 Turner Mining Group<\/strong><\/p>\n<p><strong>Job Description:<\/strong><\/p>\n<p>The Entry Level Miner is a starting point for both operations and maintenance within Turner Mining Group. This position will develop into a Production Miner or Fuel \/ Lube Technician role. The successful candidate must live the Turner Values and be an outward example to others. This position must demonstrate a strong commitment to \u201cSafe Production\u201d through decision making, priorities, and client relations.<\/p>\n<p><strong>Objectives and Contributions:<\/strong><\/p>\n<p>The Entry Level Miner is focused on key aspects that drive communication and safe production while maintaining a high level of efficiency, and preventative maintenance awareness requirements. The Entry Level Miner demonstrates safety ownership at a personal level and holds other crew members to the same high standard. <\/p>\n<ul><li>Work with employees to ensure a high level of accuracy and engagement on hazard identification and control<\/li><li>Engage crews and leadership to define processes that motivate working towards common goals<\/li><li>Assist with MSHA regulatory task training and verify compliance to standards<\/li><li>Live the values as part of a visible daily decision-making process<\/li><li>Involvement in risk assessment processes at various levels of the organization<\/li><li>Holds themselves and others accountable for acting like an owner (taking care of equipment, not wasting resources, using time wisely, and being accountable for conditions and behaviors)<\/li><li>Maintains a high standard of housekeeping (machine and work areas)<\/li><\/ul>\n<p><u>Culture and Communication:<\/u><\/p>\n<ul><li>Can effectively communicate in English (multi-lingual preferred)<\/li><li>Work with crews to support proactive near miss reporting<\/li><li>Leads by example (walks the talk)<\/li><\/ul>\n<p><u>Systems:<\/u><\/p>\n<ul><li>Trains to Turner standards to perform quality pre-operation machine inspections (Based on mobile equipment physical demands analysis)<\/li><li>Trains to Turner standards to accurately document 5000-23 and training checklist requirements<\/li><li>Other regulatory &amp; internal \/ external forms as required<\/li><li>Maintains a valid and insurable driving license<\/li><\/ul>\n<p><u>Travel and New Site Development: <\/u><\/p>\n<p><u>Time and Interactions:<\/u><\/p>\n<ul><li>The Entry Level Miner must be flexible on shift schedules (days and nights) to assist with training and production needs<\/li><li>The Entry Level Miner will be self-starting, motivated, with a strong desire to be part of a team and to influence improvement. Communication is also critical to keep leadership and site-based personnel in the loop of successes, challenges, and any additional support that may be required<\/li><li>Excellent time management skills<\/li><\/ul>\n<p><u>Qualifications:<\/u><\/p>\n<ul><li>Willingness and ability to adhere to OSHA \/ MSHA regulatory requirements<\/li><li>Entry Level Miners will be subject to a probationary period of six months from the date of hire<\/li><li>0-1 years\u2019 experience in mining \/ heavy industry preferred<\/li><li>Ability to obtain a working knowledge of safety systems and processes<\/li><li>Appropriate attention to detail required<\/li><li>Strong communication skills<\/li><li>Strong morals and values<\/li><li>Exemplary attendance record<\/li><li>Exemplary safety and disciplinary record<\/li><li>Willingness to be flexible on daily job duty requirements<\/li><li>Maintains a positive outspoken learning attitude<\/li><\/ul>\n<ul><li>The Entry Level Miner will become competent and highly proficient on each piece of the following equipment through on-the-job training and skills qualification<ul><li><strong>Water truck<\/strong><\/li><li><strong><\/strong><strong>Haulage Truc<\/strong><strong>k<\/strong><\/li><li><strong><\/strong><strong>OR<\/strong><\/li><li><strong><\/strong><strong>Preventative Maintenance<\/strong><\/li><li><strong><\/strong><strong>Fuel \/ Lube Truck<\/strong><\/li><\/ul><\/li><\/ul>\n<p><u>Other Duties:<\/u><\/p>\n<ul><li>In addition to the job skills above, there may be requirements for manual tasks to be completed to meet other business needs. Operators in any job duty classification may be required to participate in these additional tasks.<\/li><\/ul>\n<p><u><strong>Benefits<\/strong><\/u><br>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. 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>\n<p><u><br><\/u><\/p>","post_title":"Entry Level Miner","post_link":"https:\/\/turnerstaffing.com\/position\/entry-level-miner\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Entry Level","%location_country%":"United States","%location_city%":"Soda Springs","%location_state_id%":"ID","%location_state_name%":"Idaho","%location_city_state%":"Soda Springs, ID","%education%":"Unspecified","%department%":"Operations","%description%":"<p><strong>Entry Level Miner<\/strong>                    &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&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><strong>Reports to: <\/strong><strong>Foreman \u2013 Turner Mining Group<\/strong><\/p>\n<p><strong>Job Description:<\/strong><\/p>\n<p>The Entry Level Miner is a starting point for both operations and maintenance within Turner Mining Group. This position will develop into a Production Miner or Fuel \/ Lube Technician role. The successful candidate must live the Turner Values and be an outward example to others. This position must demonstrate a strong commitment to \u201cSafe Production\u201d through decision making, priorities, and client relations.<\/p>\n<p><strong>Objectives and Contributions:<\/strong><\/p>\n<p>The Entry Level Miner is focused on key aspects that drive communication and safe production while maintaining a high level of efficiency, and preventative maintenance awareness requirements. The Entry Level Miner demonstrates safety ownership at a personal level and holds other crew members to the same high standard. <\/p>\n<ul><li>Work with employees to ensure a high level of accuracy and engagement on hazard identification and control<\/li><li>Engage crews and leadership to define processes that motivate working towards common goals<\/li><li>Assist with MSHA regulatory task training and verify compliance to standards<\/li><li>Live the values as part of a visible daily decision-making process<\/li><li>Involvement in risk assessment processes at various levels of the organization<\/li><li>Holds themselves and others accountable for acting like an owner (taking care of equipment, not wasting resources, using time wisely, and being accountable for conditions and behaviors)<\/li><li>Maintains a high standard of housekeeping (machine and work areas)<\/li><\/ul>\n<p><u>Culture and Communication:<\/u><\/p>\n<ul><li>Can effectively communicate in English (multi-lingual preferred)<\/li><li>Work with crews to support proactive near miss reporting<\/li><li>Leads by example (walks the talk)<\/li><\/ul>\n<p><u>Systems:<\/u><\/p>\n<ul><li>Trains to Turner standards to perform quality pre-operation machine inspections (Based on mobile equipment physical demands analysis)<\/li><li>Trains to Turner standards to accurately document 5000-23 and training checklist requirements<\/li><li>Other regulatory &amp; internal \/ external forms as required<\/li><li>Maintains a valid and insurable driving license<\/li><\/ul>\n<p><u>Travel and New Site Development: <\/u><\/p>\n<p><u>Time and Interactions:<\/u><\/p>\n<ul><li>The Entry Level Miner must be flexible on shift schedules (days and nights) to assist with training and production needs<\/li><li>The Entry Level Miner will be self-starting, motivated, with a strong desire to be part of a team and to influence improvement. Communication is also critical to keep leadership and site-based personnel in the loop of successes, challenges, and any additional support that may be required<\/li><li>Excellent time management skills<\/li><\/ul>\n<p><u>Qualifications:<\/u><\/p>\n<ul><li>Willingness and ability to adhere to OSHA \/ MSHA regulatory requirements<\/li><li>Entry Level Miners will be subject to a probationary period of six months from the date of hire<\/li><li>0-1 years\u2019 experience in mining \/ heavy industry preferred<\/li><li>Ability to obtain a working knowledge of safety systems and processes<\/li><li>Appropriate attention to detail required<\/li><li>Strong communication skills<\/li><li>Strong morals and values<\/li><li>Exemplary attendance record<\/li><li>Exemplary safety and disciplinary record<\/li><li>Willingness to be flexible on daily job duty requirements<\/li><li>Maintains a positive outspoken learning attitude<\/li><\/ul>\n<ul><li>The Entry Level Miner will become competent and highly proficient on each piece of the following equipment through on-the-job training and skills qualification<ul><li><strong>Water truck<\/strong><\/li><li><strong><\/strong><strong>Haulage Truc<\/strong><strong>k<\/strong><\/li><li><strong><\/strong><strong>OR<\/strong><\/li><li><strong><\/strong><strong>Preventative Maintenance<\/strong><\/li><li><strong><\/strong><strong>Fuel \/ Lube Truck<\/strong><\/li><\/ul><\/li><\/ul>\n<p><u>Other Duties:<\/u><\/p>\n<ul><li>In addition to the job skills above, there may be requirements for manual tasks to be completed to meet other business needs. Operators in any job duty classification may be required to participate in these additional tasks.<\/li><\/ul>\n<p><u><strong>Benefits<\/strong><\/u><br>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. 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>\n<p><u><br><\/u><\/p>","%category%":"Operations","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/b0cbccfcb607-entry-level-miner","%breezy_id%":"b0cbccfcb607","%breezy_friendly_id%":"b0cbccfcb607-entry-level-miner","%breezy_created_date%":"2025-11-20T21:47:06.539Z","%breezy_updated_date%":"2026-01-13T19:32:05.121Z","%_wpgmp_location_city%":"Soda Springs","%_wpgmp_location_state%":"ID","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Soda Springs, ID, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"42.6543652","%_wpgmp_metabox_longitude%":"-111.6046687","%rank_math_internal_links_processed%":"1"}},"id":2916,"infowindow_disable":false},{"source":"post","title":"Equipment Operator","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Equipment Operator\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Equipment Operator &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; Reports to: Foreman \u2013 Turner Mining Group Job Description: The Equipment Operator is a skilled mining operator&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/equipment-operator\/\" name=\"Equipment Operator\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Equipment Operator &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; Reports to: Foreman \u2013 Turner Mining Group Job Description: The Equipment Operator is a skilled mining operator&hellip;","address":"Soda Springs, ID, USA","location":{"lat":"42.6543652","city":"Soda Springs","state":"ID","country":"United States","lng":"-111.6046687","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/equipment-operator\/","zoom":19,"extra_fields":{"post_excerpt":"Equipment Operator &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; Reports to: Foreman \u2013 Turner Mining Group Job Description: The Equipment Operator is a skilled mining operator&hellip;","post_content":"<p><strong>Equipment Operator<\/strong>                &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&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><strong>Reports to: <\/strong><strong>Foreman \u2013 Turner Mining Group<\/strong><\/p>\n<p><strong>Job Description:<\/strong><\/p>\n<p>The Equipment Operator is a skilled mining operator position within Turner Mining Group. The successful candidate must live the Turner Values and be an outward example to others. This position must demonstrate a strong commitment to \u201cSafe Production\u201d through decision making, priorities, and client relations.<\/p>\n<p><strong>Objectives and Contributions:<\/strong><\/p>\n<p>The Equipment Operator is focused on key aspects that drive communication and safe production while maintaining a high level of efficiency, and preventative maintenance awareness requirements. The Operator demonstrates safety ownership at a personal level and holds other crew members to the same high standard.&nbsp; The Equipment Operator will train and develop into the Senior Equipment Operator job scope while the Senior Equipment operator is filling in for the Lead job duties. <\/p>\n<ul><li>Work with employees to ensure a high level of accuracy and engagement on hazard identification and control<\/li><li>Engage crews and leadership to define processes that motivate working towards common goals<\/li><li>Assist with MSHA regulatory task training and verify compliance to standards<\/li><li>Live the values as part of a visible daily decision-making process<\/li><li>Assist with training proficiency audits<\/li><li>Involvement in risk assessment processes at various levels of the organization<\/li><li>Holds themselves and others accountable for acting like an owner (taking care of equipment, not wasting resources, using time wisely, and being accountable for conditions and behaviors)<\/li><li>Maintains a high standard of housekeeping (machine and work areas)<\/li><\/ul>\n<p><u>Culture and Communication:<\/u><\/p>\n<ul><li>Can effectively communicate in English (multi-lingual preferred)<\/li><li>Participate in site and project leaders to identify areas of improvement<\/li><li>Work with crews to support proactive near miss reporting<\/li><li>Leads by example (walks the talk)<\/li><\/ul>\n<p><u>Systems:<\/u><\/p>\n<ul><li>Ability to perform quality pre-operation machine inspections (Based on mobile equipment physical demands analysis)<\/li><li>Accurately documents 5000-23 and training checklist requirements<\/li><li>Other regulatory &amp; internal \/ external forms as required<\/li><\/ul>\n<p><u>Travel and New Site Development:<\/u><\/p>\n<ul><li>Maintains a valid and insurable driving license<\/li><li>Available to travel on short notice to support timelines and production requirements at existing sites<\/li><\/ul>\n<p><u>Time and Interactions:<\/u><\/p>\n<ul><li>The Equipment Operator must be flexible on shift schedules (days and nights) to assist with training and production needs<\/li><li>The Equipment Operator will be self-starting, motivated, with a strong desire to be part of a team and to influence improvement. Communication is also critical to keep leadership and site-based personnel in the loop of successes, challenges, and any additional support that may be required<\/li><li>Excellent time management skills<\/li><\/ul>\n<p><u>Qualifications:<\/u><\/p>\n<ul><li>Willingness and ability to adhere to OSHA \/ MSHA regulatory requirements<\/li><li>1-3 years\u2019 experience in mining \/ heavy industry preferred<\/li><li>Working knowledge of safety systems and processes<\/li><li>Appropriate attention to detail required<\/li><li>Strong communication skills<\/li><li>Strong morals and values<\/li><li>Exemplary attendance record<\/li><li>Exemplary safety and disciplinary record<\/li><li>Willingness to be flexible on daily job duty requirements<\/li><li>Maintains a positive outspoken learning attitude<\/li><li>The Equipment Operator must pass and maintain Turner Mining Group mobile equipment skills qualifications on each piece of the following equipment: <ul><li><strong>Support excavator<\/strong><\/li><li><strong><\/strong><strong>Dozer<\/strong><\/li><li><strong><\/strong><strong>Support loader<\/strong><\/li><li><strong><\/strong><strong>Grader<\/strong><\/li><li><strong><\/strong><strong>Water truck<\/strong><\/li><li><strong><\/strong><strong>Haulage truck<\/strong><\/li><\/ul><\/li><\/ul>\n<p><u>Other Duties:<\/u><\/p>\n<ul><li>In addition to the job skills above, there may be requirements for manual tasks to be completed to meet other business needs. Operators in any job duty classification may be required to participate in these additional tasks.<u><\/u><\/li><\/ul>\n<p><u><strong>Benefits<\/strong><\/u><br>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. 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 Operator","post_link":"https:\/\/turnerstaffing.com\/position\/equipment-operator\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Associate","%location_country%":"United States","%location_city%":"Soda Springs","%location_state_id%":"ID","%location_state_name%":"Idaho","%location_city_state%":"Soda Springs, ID","%education%":"Unspecified","%department%":"Operations","%description%":"<p><strong>Equipment Operator<\/strong>                &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&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><strong>Reports to: <\/strong><strong>Foreman \u2013 Turner Mining Group<\/strong><\/p>\n<p><strong>Job Description:<\/strong><\/p>\n<p>The Equipment Operator is a skilled mining operator position within Turner Mining Group. The successful candidate must live the Turner Values and be an outward example to others. This position must demonstrate a strong commitment to \u201cSafe Production\u201d through decision making, priorities, and client relations.<\/p>\n<p><strong>Objectives and Contributions:<\/strong><\/p>\n<p>The Equipment Operator is focused on key aspects that drive communication and safe production while maintaining a high level of efficiency, and preventative maintenance awareness requirements. The Operator demonstrates safety ownership at a personal level and holds other crew members to the same high standard.&nbsp; The Equipment Operator will train and develop into the Senior Equipment Operator job scope while the Senior Equipment operator is filling in for the Lead job duties. <\/p>\n<ul><li>Work with employees to ensure a high level of accuracy and engagement on hazard identification and control<\/li><li>Engage crews and leadership to define processes that motivate working towards common goals<\/li><li>Assist with MSHA regulatory task training and verify compliance to standards<\/li><li>Live the values as part of a visible daily decision-making process<\/li><li>Assist with training proficiency audits<\/li><li>Involvement in risk assessment processes at various levels of the organization<\/li><li>Holds themselves and others accountable for acting like an owner (taking care of equipment, not wasting resources, using time wisely, and being accountable for conditions and behaviors)<\/li><li>Maintains a high standard of housekeeping (machine and work areas)<\/li><\/ul>\n<p><u>Culture and Communication:<\/u><\/p>\n<ul><li>Can effectively communicate in English (multi-lingual preferred)<\/li><li>Participate in site and project leaders to identify areas of improvement<\/li><li>Work with crews to support proactive near miss reporting<\/li><li>Leads by example (walks the talk)<\/li><\/ul>\n<p><u>Systems:<\/u><\/p>\n<ul><li>Ability to perform quality pre-operation machine inspections (Based on mobile equipment physical demands analysis)<\/li><li>Accurately documents 5000-23 and training checklist requirements<\/li><li>Other regulatory &amp; internal \/ external forms as required<\/li><\/ul>\n<p><u>Travel and New Site Development:<\/u><\/p>\n<ul><li>Maintains a valid and insurable driving license<\/li><li>Available to travel on short notice to support timelines and production requirements at existing sites<\/li><\/ul>\n<p><u>Time and Interactions:<\/u><\/p>\n<ul><li>The Equipment Operator must be flexible on shift schedules (days and nights) to assist with training and production needs<\/li><li>The Equipment Operator will be self-starting, motivated, with a strong desire to be part of a team and to influence improvement. Communication is also critical to keep leadership and site-based personnel in the loop of successes, challenges, and any additional support that may be required<\/li><li>Excellent time management skills<\/li><\/ul>\n<p><u>Qualifications:<\/u><\/p>\n<ul><li>Willingness and ability to adhere to OSHA \/ MSHA regulatory requirements<\/li><li>1-3 years\u2019 experience in mining \/ heavy industry preferred<\/li><li>Working knowledge of safety systems and processes<\/li><li>Appropriate attention to detail required<\/li><li>Strong communication skills<\/li><li>Strong morals and values<\/li><li>Exemplary attendance record<\/li><li>Exemplary safety and disciplinary record<\/li><li>Willingness to be flexible on daily job duty requirements<\/li><li>Maintains a positive outspoken learning attitude<\/li><li>The Equipment Operator must pass and maintain Turner Mining Group mobile equipment skills qualifications on each piece of the following equipment: <ul><li><strong>Support excavator<\/strong><\/li><li><strong><\/strong><strong>Dozer<\/strong><\/li><li><strong><\/strong><strong>Support loader<\/strong><\/li><li><strong><\/strong><strong>Grader<\/strong><\/li><li><strong><\/strong><strong>Water truck<\/strong><\/li><li><strong><\/strong><strong>Haulage truck<\/strong><\/li><\/ul><\/li><\/ul>\n<p><u>Other Duties:<\/u><\/p>\n<ul><li>In addition to the job skills above, there may be requirements for manual tasks to be completed to meet other business needs. Operators in any job duty classification may be required to participate in these additional tasks.<u><\/u><\/li><\/ul>\n<p><u><strong>Benefits<\/strong><\/u><br>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. 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\/82bfa4c13196-equipment-operator","%breezy_id%":"82bfa4c13196","%breezy_friendly_id%":"82bfa4c13196-equipment-operator","%breezy_created_date%":"2025-11-20T21:48:13.932Z","%breezy_updated_date%":"2026-01-06T16:22:42.767Z","%_wpgmp_location_city%":"Soda Springs","%_wpgmp_location_state%":"ID","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Soda Springs, ID, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"42.6543652","%_wpgmp_metabox_longitude%":"-111.6046687","%rank_math_internal_links_processed%":"1"}},"id":2917,"infowindow_disable":false},{"source":"post","title":"Heavy Equipment Fuel &amp; Lube Technician","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Heavy Equipment Fuel &amp; Lube Technician\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Fuel \/ Lube Technician &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; Reports to: Foreman \u2013 Turner Mining Group Job Description: The Fuel \/ Lube Technician is&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/fuel-lube-technician\/\" name=\"Heavy Equipment Fuel &amp; Lube Technician\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Fuel \/ Lube Technician &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; Reports to: Foreman \u2013 Turner Mining Group Job Description: The Fuel \/ Lube Technician is&hellip;","address":"Soda Springs, ID, USA","location":{"lat":"42.6543652","city":"Soda Springs","state":"ID","country":"United States","lng":"-111.6046687","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/fuel-lube-technician\/","zoom":19,"extra_fields":{"post_excerpt":"Fuel \/ Lube Technician &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; Reports to: Foreman \u2013 Turner Mining Group Job Description: The Fuel \/ Lube Technician is&hellip;","post_content":"<p><strong>Fuel \/ Lube Technician<\/strong>                &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&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><strong>Reports to: <\/strong><strong>Foreman \u2013 Turner Mining Group<\/strong><\/p>\n<p><strong>Job Description:<\/strong><\/p>\n<p>The Fuel \/ Lube Technician is a developing Maintenance Technician role within Turner Mining Group. This role will be focused on maintaining equipment. The successful candidate must live the Turner Values and be an outward example to others. This position must demonstrate a strong commitment to \u201cSafe Production\u201d through decision making, priorities, and client relations.<\/p>\n<p><strong>Objectives and Contributions:<\/strong><\/p>\n<p>The Fuel \/ Lube Technician is focused on key aspects that drive communication and safe production while maintaining a high level of efficiency, proactive training metrics, and preventative maintenance awareness requirements. The Fuel \/ Lube Technician demonstrates safety ownership at a personal level and holds other crew members to the same high standard.&nbsp; The Fuel \/ Lube Technician also assists in other production support functions as assigned.<\/p>\n<ul><li>Work with employees to ensure a high level of accuracy and engagement on hazard identification and control<\/li><li>Engage crews and leadership to define processes that motivate working towards common goals<\/li><li>Assist with MSHA regulatory training and verify compliance to standards<\/li><li>Live the values as part of a visible daily decision-making process<\/li><li>Assist with training proficiency audits<\/li><li>Involvement in risk assessment processes at various levels of the organization<\/li><li>Holds themselves and others accountable for acting like an owner (taking care of equipment, not wasting resources, using time wisely, and being accountable for conditions and behaviors)<\/li><li>Maintains a high standard of housekeeping (machine and work areas)<\/li><\/ul>\n<p><u>Culture and Communication:<\/u><\/p>\n<ul><li>Can effectively communicate in English (multi-lingual preferred)<\/li><li>Participate with site and project leaders to identify areas of improvement<\/li><li>Work with crews to support proactive near miss reporting<\/li><li>Leads by example (walks the talk)<\/li><\/ul>\n<p><u>Systems:<\/u><\/p>\n<ul><li>Ability to perform quality pre-operation machine inspections (Based on mobile equipment physical demands analysis)<\/li><li>Accurately documents 5000-23 and training checklist requirements<\/li><li>Other regulatory &amp; internal \/ external forms as required<\/li><li>Maintains a valid and insurable driving license<\/li><\/ul>\n<p><u>Travel and New Site Development: <\/u><\/p>\n<p><u>Time and Interactions:<\/u><\/p>\n<ul><li>The Fuel \/ Lube Technician must be flexible on shift schedules (days and nights) to assist with training and production needs<\/li><li>The Fuel \/ Lube Technician will be self-starting, motivated, with a strong desire to be part of a team and to influence improvement. Communication is also critical to keep leadership and site-based personnel in the loop of successes, challenges, and any additional support that may be required<\/li><li>Excellent time management skills<\/li><\/ul>\n<p><u>Qualifications:<\/u><\/p>\n<ul><li>Willingness and ability to adhere to OSHA \/ MSHA regulatory requirements<\/li><li>0-2 years\u2019 experience in mining \/ heavy industry preferred<\/li><li>Working knowledge of safety systems and processes<\/li><li>Appropriate attention to detail required<\/li><li>Strong communication skills<\/li><li>Strong morals and values<\/li><li>Exemplary attendance record<\/li><li>Exemplary safety and disciplinary record<\/li><li>Willingness to be flexible on daily job duty requirements<\/li><li>Maintains a positive outspoken learning attitude<\/li><li>The Fuel \/ Lube Technician must be able to safely perform each of the following tasks: <ul><li><strong>Fuel \/ lube Truck<\/strong><\/li><li><strong><\/strong><strong>Fueling \/ lubing equipment<\/strong><\/li><li><strong><\/strong><strong>Equipment fluid level monitoring<\/strong><\/li><li><strong><\/strong><strong>Marshalling equipment<\/strong><\/li><li><strong><\/strong><strong>Washing equipment<\/strong><\/li><\/ul><\/li><\/ul>\n<p><u>Other Duties:<\/u><\/p>\n<ul><li>In addition to the job skills above, there may be requirements for manual tasks to be completed to meet other business needs. Operators in any job duty classification may be required to participate in these additional tasks.<\/li><\/ul>\n<p><u><strong>Benefits<\/strong><\/u><br>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. 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":"Heavy Equipment Fuel &amp; Lube Technician","post_link":"https:\/\/turnerstaffing.com\/position\/fuel-lube-technician\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Entry Level","%location_country%":"United States","%location_city%":"Soda Springs","%location_state_id%":"ID","%location_state_name%":"Idaho","%location_city_state%":"Soda Springs, ID","%education%":"Unspecified","%department%":"Maintenance","%description%":"<p><strong>Fuel \/ Lube Technician<\/strong>                &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&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><strong>Reports to: <\/strong><strong>Foreman \u2013 Turner Mining Group<\/strong><\/p>\n<p><strong>Job Description:<\/strong><\/p>\n<p>The Fuel \/ Lube Technician is a developing Maintenance Technician role within Turner Mining Group. This role will be focused on maintaining equipment. The successful candidate must live the Turner Values and be an outward example to others. This position must demonstrate a strong commitment to \u201cSafe Production\u201d through decision making, priorities, and client relations.<\/p>\n<p><strong>Objectives and Contributions:<\/strong><\/p>\n<p>The Fuel \/ Lube Technician is focused on key aspects that drive communication and safe production while maintaining a high level of efficiency, proactive training metrics, and preventative maintenance awareness requirements. The Fuel \/ Lube Technician demonstrates safety ownership at a personal level and holds other crew members to the same high standard.&nbsp; The Fuel \/ Lube Technician also assists in other production support functions as assigned.<\/p>\n<ul><li>Work with employees to ensure a high level of accuracy and engagement on hazard identification and control<\/li><li>Engage crews and leadership to define processes that motivate working towards common goals<\/li><li>Assist with MSHA regulatory training and verify compliance to standards<\/li><li>Live the values as part of a visible daily decision-making process<\/li><li>Assist with training proficiency audits<\/li><li>Involvement in risk assessment processes at various levels of the organization<\/li><li>Holds themselves and others accountable for acting like an owner (taking care of equipment, not wasting resources, using time wisely, and being accountable for conditions and behaviors)<\/li><li>Maintains a high standard of housekeeping (machine and work areas)<\/li><\/ul>\n<p><u>Culture and Communication:<\/u><\/p>\n<ul><li>Can effectively communicate in English (multi-lingual preferred)<\/li><li>Participate with site and project leaders to identify areas of improvement<\/li><li>Work with crews to support proactive near miss reporting<\/li><li>Leads by example (walks the talk)<\/li><\/ul>\n<p><u>Systems:<\/u><\/p>\n<ul><li>Ability to perform quality pre-operation machine inspections (Based on mobile equipment physical demands analysis)<\/li><li>Accurately documents 5000-23 and training checklist requirements<\/li><li>Other regulatory &amp; internal \/ external forms as required<\/li><li>Maintains a valid and insurable driving license<\/li><\/ul>\n<p><u>Travel and New Site Development: <\/u><\/p>\n<p><u>Time and Interactions:<\/u><\/p>\n<ul><li>The Fuel \/ Lube Technician must be flexible on shift schedules (days and nights) to assist with training and production needs<\/li><li>The Fuel \/ Lube Technician will be self-starting, motivated, with a strong desire to be part of a team and to influence improvement. Communication is also critical to keep leadership and site-based personnel in the loop of successes, challenges, and any additional support that may be required<\/li><li>Excellent time management skills<\/li><\/ul>\n<p><u>Qualifications:<\/u><\/p>\n<ul><li>Willingness and ability to adhere to OSHA \/ MSHA regulatory requirements<\/li><li>0-2 years\u2019 experience in mining \/ heavy industry preferred<\/li><li>Working knowledge of safety systems and processes<\/li><li>Appropriate attention to detail required<\/li><li>Strong communication skills<\/li><li>Strong morals and values<\/li><li>Exemplary attendance record<\/li><li>Exemplary safety and disciplinary record<\/li><li>Willingness to be flexible on daily job duty requirements<\/li><li>Maintains a positive outspoken learning attitude<\/li><li>The Fuel \/ Lube Technician must be able to safely perform each of the following tasks: <ul><li><strong>Fuel \/ lube Truck<\/strong><\/li><li><strong><\/strong><strong>Fueling \/ lubing equipment<\/strong><\/li><li><strong><\/strong><strong>Equipment fluid level monitoring<\/strong><\/li><li><strong><\/strong><strong>Marshalling equipment<\/strong><\/li><li><strong><\/strong><strong>Washing equipment<\/strong><\/li><\/ul><\/li><\/ul>\n<p><u>Other Duties:<\/u><\/p>\n<ul><li>In addition to the job skills above, there may be requirements for manual tasks to be completed to meet other business needs. Operators in any job duty classification may be required to participate in these additional tasks.<\/li><\/ul>\n<p><u><strong>Benefits<\/strong><\/u><br>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. 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%":"Other","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/b3bd97ef3942-heavy-equipment-fuel-lube-technician","%breezy_id%":"b3bd97ef3942","%breezy_friendly_id%":"b3bd97ef3942-heavy-equipment-fuel-lube-technician","%breezy_created_date%":"2025-11-20T21:50:25.985Z","%breezy_updated_date%":"2026-01-13T19:47:52.850Z","%_wpgmp_location_city%":"Soda Springs","%_wpgmp_location_state%":"ID","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Soda Springs, ID, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"42.6543652","%_wpgmp_metabox_longitude%":"-111.6046687","%rank_math_internal_links_processed%":"1"}},"id":2918,"infowindow_disable":false},{"source":"post","title":"Heavy Equipment Maintenance Technician &#8211; Mining","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Heavy Equipment Maintenance Technician &#8211; Mining\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Maintenance Technician &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; Reports to: Foreman \u2013 Turner Mining Group Job Description: The Maintenance Technician is a skilled mining maintenance&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/maintenance-technician\/\" name=\"Heavy Equipment Maintenance Technician &#8211; Mining\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Maintenance Technician &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; Reports to: Foreman \u2013 Turner Mining Group Job Description: The Maintenance Technician is a skilled mining maintenance&hellip;","address":"Soda Springs, ID, USA","location":{"lat":"42.6543652","city":"Soda Springs","state":"ID","country":"United States","lng":"-111.6046687","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/maintenance-technician\/","zoom":19,"extra_fields":{"post_excerpt":"Maintenance Technician &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; Reports to: Foreman \u2013 Turner Mining Group Job Description: The Maintenance Technician is a skilled mining maintenance&hellip;","post_content":"<p><strong>Maintenance Technician<\/strong>                &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&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><strong>Reports to: <\/strong><strong>Foreman \u2013 Turner Mining Group<\/strong><\/p>\n<p><strong>Job Description:<\/strong><\/p>\n<p>The Maintenance Technician is a skilled mining maintenance position within Turner Mining Group. This position will focus on maintaining equipment. The successful candidate must live the Turner Values and be an outward example to others. This position must demonstrate a strong commitment to \u201cSafe Production\u201d through decision making, priorities, and client relations.<\/p>\n<p><strong>Objectives and Contributions:<\/strong><\/p>\n<p>The Maintenance Technician is focused on key aspects that drive communication and safe production while maintaining a high level of efficiency, proactive training metrics, and preventative maintenance awareness requirements. The Maintenance Technician demonstrates safety ownership at a personal level and holds other crew members to the same high standard.&nbsp; The Maintenance Technician also assists in other production support functions as assigned.<\/p>\n<ul><li>Work with employees to ensure a high level of accuracy and engagement on hazard identification and control<\/li><li>Engage crews and leadership to define processes that motivate working towards common goals<\/li><li>Assist with MSHA regulatory training and verify compliance to standards<\/li><li>Live the values as part of a visible daily decision-making process<\/li><li>Assist with training proficiency audits<\/li><li>Involvement in risk assessment processes at various levels of the organization<\/li><li>Holds themselves and others accountable for acting like an owner (taking care of equipment, not wasting resources, using time wisely, and being accountable for conditions and behaviors)<\/li><li>Maintains a high standard of housekeeping (machine and work areas)<\/li><\/ul>\n<p><u>Culture and Communication:<\/u><\/p>\n<ul><li>Can effectively communicate in English (multi-lingual preferred)<\/li><li>Participate with site and project leaders to identify areas of improvement<\/li><li>Work with crews to support proactive near miss reporting<\/li><li>Leads by example (walks the talk)<\/li><\/ul>\n<p><u>Systems:<\/u><\/p>\n<ul><li>Ability to perform quality pre-operation machine inspections (Based on mobile equipment physical demands analysis)<\/li><li>Accurately documents 5000-23 and training checklist requirements<\/li><li>Other regulatory &amp; internal \/ external forms as required<\/li><\/ul>\n<p><u>Travel and New Site Development: <\/u><\/p>\n<ul><li>Maintains a valid and insurable driving license<\/li><li>Available to travel on short notice to support timelines and production requirements at existing sites <strong>(Preferred)<\/strong><\/li><\/ul>\n<p><u>Time and Interactions:<\/u><\/p>\n<ul><li>The Maintenance Technician must be flexible on shift schedules (days and nights) to assist with training and production needs<\/li><li>The Maintenance Technician will be self-starting, motivated, with a strong desire to be part of a team and to influence improvement. Communication is also critical to keep leadership and site-based personnel in the loop of successes, challenges, and any additional support that may be required<\/li><li>Excellent time management skills<\/li><\/ul>\n<p><u>Qualifications:<\/u><\/p>\n<ul><li>Willingness and ability to adhere to OSHA \/ MSHA regulatory requirements<\/li><li>1-3 years\u2019 experience in mining \/ heavy industry preferred<\/li><li>Working knowledge of safety systems and processes<\/li><li>Appropriate attention to detail required<\/li><li>Strong communication skills<\/li><li>Strong morals and values<\/li><li>Exemplary attendance record<\/li><li>Exemplary safety and disciplinary record<\/li><li>Willingness to be flexible on daily job duty requirements<\/li><li>Maintains a positive outspoken learning attitude<\/li><li>The Maintenance Technician must be able to safely perform each of the following tasks: <ul><li><strong>Maintenance service truck<\/strong><\/li><li><strong><\/strong><strong>G.E.T replacement<\/strong><\/li><li><strong><\/strong><strong>Replacing equipment attachments<\/strong><\/li><li><strong><\/strong><strong>Minor equipment repairs<\/strong><\/li><li><strong><\/strong><strong>Preventative maintenance backlog repairs<\/strong><\/li><li><strong><\/strong><strong>Fuel \/ lube Truck<\/strong><\/li><li><strong><\/strong><strong>Fueling \/ lubing equipment<\/strong><\/li><li><strong><\/strong><strong>Equipment fluid level monitoring<\/strong><\/li><li><strong><\/strong><strong>Marshalling equipment<\/strong><\/li><li><strong><\/strong><strong>Washing equipment<\/strong><\/li><\/ul><\/li><\/ul>\n<p><u>Other Duties:<\/u><\/p>\n<ul><li>In addition to the job skills above, there may be requirements for manual tasks to be completed to meet other business needs. Operators in any job duty classification may be required to participate in these additional tasks.<u><\/u><\/li><\/ul>\n<p><u><strong>Benefits<\/strong><\/u><br>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. 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":"Heavy Equipment Maintenance Technician &#8211; Mining","post_link":"https:\/\/turnerstaffing.com\/position\/maintenance-technician\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Associate","%location_country%":"United States","%location_city%":"Soda Springs","%location_state_id%":"ID","%location_state_name%":"Idaho","%location_city_state%":"Soda Springs, ID","%education%":"Unspecified","%department%":"Maintenance","%description%":"<p><strong>Maintenance Technician<\/strong>                &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&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><strong>Reports to: <\/strong><strong>Foreman \u2013 Turner Mining Group<\/strong><\/p>\n<p><strong>Job Description:<\/strong><\/p>\n<p>The Maintenance Technician is a skilled mining maintenance position within Turner Mining Group. This position will focus on maintaining equipment. The successful candidate must live the Turner Values and be an outward example to others. This position must demonstrate a strong commitment to \u201cSafe Production\u201d through decision making, priorities, and client relations.<\/p>\n<p><strong>Objectives and Contributions:<\/strong><\/p>\n<p>The Maintenance Technician is focused on key aspects that drive communication and safe production while maintaining a high level of efficiency, proactive training metrics, and preventative maintenance awareness requirements. The Maintenance Technician demonstrates safety ownership at a personal level and holds other crew members to the same high standard.&nbsp; The Maintenance Technician also assists in other production support functions as assigned.<\/p>\n<ul><li>Work with employees to ensure a high level of accuracy and engagement on hazard identification and control<\/li><li>Engage crews and leadership to define processes that motivate working towards common goals<\/li><li>Assist with MSHA regulatory training and verify compliance to standards<\/li><li>Live the values as part of a visible daily decision-making process<\/li><li>Assist with training proficiency audits<\/li><li>Involvement in risk assessment processes at various levels of the organization<\/li><li>Holds themselves and others accountable for acting like an owner (taking care of equipment, not wasting resources, using time wisely, and being accountable for conditions and behaviors)<\/li><li>Maintains a high standard of housekeeping (machine and work areas)<\/li><\/ul>\n<p><u>Culture and Communication:<\/u><\/p>\n<ul><li>Can effectively communicate in English (multi-lingual preferred)<\/li><li>Participate with site and project leaders to identify areas of improvement<\/li><li>Work with crews to support proactive near miss reporting<\/li><li>Leads by example (walks the talk)<\/li><\/ul>\n<p><u>Systems:<\/u><\/p>\n<ul><li>Ability to perform quality pre-operation machine inspections (Based on mobile equipment physical demands analysis)<\/li><li>Accurately documents 5000-23 and training checklist requirements<\/li><li>Other regulatory &amp; internal \/ external forms as required<\/li><\/ul>\n<p><u>Travel and New Site Development: <\/u><\/p>\n<ul><li>Maintains a valid and insurable driving license<\/li><li>Available to travel on short notice to support timelines and production requirements at existing sites <strong>(Preferred)<\/strong><\/li><\/ul>\n<p><u>Time and Interactions:<\/u><\/p>\n<ul><li>The Maintenance Technician must be flexible on shift schedules (days and nights) to assist with training and production needs<\/li><li>The Maintenance Technician will be self-starting, motivated, with a strong desire to be part of a team and to influence improvement. Communication is also critical to keep leadership and site-based personnel in the loop of successes, challenges, and any additional support that may be required<\/li><li>Excellent time management skills<\/li><\/ul>\n<p><u>Qualifications:<\/u><\/p>\n<ul><li>Willingness and ability to adhere to OSHA \/ MSHA regulatory requirements<\/li><li>1-3 years\u2019 experience in mining \/ heavy industry preferred<\/li><li>Working knowledge of safety systems and processes<\/li><li>Appropriate attention to detail required<\/li><li>Strong communication skills<\/li><li>Strong morals and values<\/li><li>Exemplary attendance record<\/li><li>Exemplary safety and disciplinary record<\/li><li>Willingness to be flexible on daily job duty requirements<\/li><li>Maintains a positive outspoken learning attitude<\/li><li>The Maintenance Technician must be able to safely perform each of the following tasks: <ul><li><strong>Maintenance service truck<\/strong><\/li><li><strong><\/strong><strong>G.E.T replacement<\/strong><\/li><li><strong><\/strong><strong>Replacing equipment attachments<\/strong><\/li><li><strong><\/strong><strong>Minor equipment repairs<\/strong><\/li><li><strong><\/strong><strong>Preventative maintenance backlog repairs<\/strong><\/li><li><strong><\/strong><strong>Fuel \/ lube Truck<\/strong><\/li><li><strong><\/strong><strong>Fueling \/ lubing equipment<\/strong><\/li><li><strong><\/strong><strong>Equipment fluid level monitoring<\/strong><\/li><li><strong><\/strong><strong>Marshalling equipment<\/strong><\/li><li><strong><\/strong><strong>Washing equipment<\/strong><\/li><\/ul><\/li><\/ul>\n<p><u>Other Duties:<\/u><\/p>\n<ul><li>In addition to the job skills above, there may be requirements for manual tasks to be completed to meet other business needs. Operators in any job duty classification may be required to participate in these additional tasks.<u><\/u><\/li><\/ul>\n<p><u><strong>Benefits<\/strong><\/u><br>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. 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\/ceda8f2ea834-heavy-equipment-maintenance-technician-mining","%breezy_id%":"ceda8f2ea834","%breezy_friendly_id%":"ceda8f2ea834-heavy-equipment-maintenance-technician-mining","%breezy_created_date%":"2025-11-20T21:51:50.805Z","%breezy_updated_date%":"2026-01-06T19:48:28.012Z","%_wpgmp_location_city%":"Soda Springs","%_wpgmp_location_state%":"ID","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Soda Springs, ID, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"42.6543652","%_wpgmp_metabox_longitude%":"-111.6046687","%rank_math_internal_links_processed%":"1"}},"id":2919,"infowindow_disable":false},{"source":"post","title":"Director of Quality Control","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Director of Quality Control\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Our client&nbsp;is&nbsp;looking for a&nbsp;Director of Quality Control&nbsp;who will work alongside Production Operations to ensure the highest level of quality for&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/director-of-quality-control\/\" name=\"Director of Quality Control\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Our client&nbsp;is&nbsp;looking for a&nbsp;Director of Quality Control&nbsp;who will work alongside Production Operations to ensure the highest level of quality for&hellip;","address":"Houston, TX, USA","location":{"lat":"29.7600771","city":"Houston","state":"TX","country":"United States","lng":"-95.3701108","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/director-of-quality-control\/","zoom":19,"extra_fields":{"post_excerpt":"Our client&nbsp;is&nbsp;looking for a&nbsp;Director of Quality Control&nbsp;who will work alongside Production Operations to ensure the highest level of quality for&hellip;","post_content":"<p>Our client&nbsp;is&nbsp;looking for a&nbsp;Director of Quality Control&nbsp;who will work alongside Production Operations to ensure the highest level of quality for their products.&nbsp;By providing leadership and oversight,&nbsp;the&nbsp;Director of Quality Control&nbsp;helps foster a culture of quality within the organization, ensuring that the company's products or services meet or exceed customer expectations.&nbsp;In this role, the&nbsp;Director of Quality Control&nbsp;will work closely with multiple departments across the facility, ensuring that all teams are aware of and adhere to the quality assurance requirements specific to each project.&nbsp;By maintaining a clear focus on safety, environmental compliance, and quality, the&nbsp;Director of Quality Control&nbsp;not only ensures the production of high-quality products but also helps protect employees and the environment, while adhering to all relevant regulations.<\/p>\n<p><strong>Responsibilities<\/strong><\/p>\n<ul><li>Lead&nbsp;and manage the QC team&nbsp;in performing visual inspections of products, ensuring compliance with both internal and client standards.<\/li><li>Develop and deliver quality control training programs to key personnel in collaboration with managers.<\/li><li>Coordinate with managers to implement quality control training programs for key personnel.<\/li><li>Collaborate with&nbsp;senior management&nbsp;teams to resolve quality issues and drive continuous improvement.<\/li><li>Establish, implement, and oversee quality control procedures across all operational areas to maintain consistency and uphold high-quality standards.<\/li><li>Review and approve quality reports, ensuring accuracy and the integrity of data collected during audits and inspections.<\/li><li>Ensure non-conforming products are accurately identified, retained, and handled according to company procedures, preventing their release until compliance is confirmed.<\/li><li>Implement and enforce environment, health, and safety protocols as they relate to the QC&nbsp;function, ensuring compliance with all regulatory standards.<\/li><li>Provide continuous feedback and recommendations to improve processes and enhance quality control measures.<\/li><li>Hold quarterly QC meetings (including Engineering &amp; Production departments) to review quality issues\/concerns<br>&nbsp;<\/li><\/ul>\n<p><strong>Desired Qualifications<\/strong><\/p>\n<ul><li>Knowledge of concrete technology, welding, and nondestructive evaluation\/testing (NDE\/NDT).<\/li><li>ACI certifications.<\/li><li>Understanding and adhere to&nbsp;ASTM, ASSHTO<\/li><\/ul>\n<p>&nbsp;&nbsp;<strong>The physical demands described here are representative of those that must be met by an employee to successfully perform the essential functions of this job.<\/strong><\/p>\n<ul><li>Ability to lift up to 50 lbs.<\/li><li>Standing, walking and stooping throughout the shift.<\/li><li>Ability to keep up with manufacturing requirements.<\/li><li>Ability to meet attendance schedule with dependability and consistency<\/li><li>Ability to use tools and&nbsp;equipment properly and safely.<\/li><li>Ability to lift heavy objects, walk and stand for long periods of time and perform strenuous physical labor under adverse field conditions.<\/li><li>Able to work with dust and outside environment conditions<\/li><li>Used&nbsp;to wearing earplugs and other PPE<\/li><\/ul>","post_title":"Director of Quality Control","post_link":"https:\/\/turnerstaffing.com\/position\/director-of-quality-control\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"","%location_country%":"United States","%location_city%":"Houston","%location_state_id%":"TX","%location_state_name%":"Texas","%location_city_state%":"Houston, TX","%education%":"High School or Equivalent","%department%":"","%description%":"<p>Our client&nbsp;is&nbsp;looking for a&nbsp;Director of Quality Control&nbsp;who will work alongside Production Operations to ensure the highest level of quality for their products.&nbsp;By providing leadership and oversight,&nbsp;the&nbsp;Director of Quality Control&nbsp;helps foster a culture of quality within the organization, ensuring that the company's products or services meet or exceed customer expectations.&nbsp;In this role, the&nbsp;Director of Quality Control&nbsp;will work closely with multiple departments across the facility, ensuring that all teams are aware of and adhere to the quality assurance requirements specific to each project.&nbsp;By maintaining a clear focus on safety, environmental compliance, and quality, the&nbsp;Director of Quality Control&nbsp;not only ensures the production of high-quality products but also helps protect employees and the environment, while adhering to all relevant regulations.<\/p>\n<p><strong>Responsibilities<\/strong><\/p>\n<ul><li>Lead&nbsp;and manage the QC team&nbsp;in performing visual inspections of products, ensuring compliance with both internal and client standards.<\/li><li>Develop and deliver quality control training programs to key personnel in collaboration with managers.<\/li><li>Coordinate with managers to implement quality control training programs for key personnel.<\/li><li>Collaborate with&nbsp;senior management&nbsp;teams to resolve quality issues and drive continuous improvement.<\/li><li>Establish, implement, and oversee quality control procedures across all operational areas to maintain consistency and uphold high-quality standards.<\/li><li>Review and approve quality reports, ensuring accuracy and the integrity of data collected during audits and inspections.<\/li><li>Ensure non-conforming products are accurately identified, retained, and handled according to company procedures, preventing their release until compliance is confirmed.<\/li><li>Implement and enforce environment, health, and safety protocols as they relate to the QC&nbsp;function, ensuring compliance with all regulatory standards.<\/li><li>Provide continuous feedback and recommendations to improve processes and enhance quality control measures.<\/li><li>Hold quarterly QC meetings (including Engineering &amp; Production departments) to review quality issues\/concerns<br>&nbsp;<\/li><\/ul>\n<p><strong>Desired Qualifications<\/strong><\/p>\n<ul><li>Knowledge of concrete technology, welding, and nondestructive evaluation\/testing (NDE\/NDT).<\/li><li>ACI certifications.<\/li><li>Understanding and adhere to&nbsp;ASTM, ASSHTO<\/li><\/ul>\n<p>&nbsp;&nbsp;<strong>The physical demands described here are representative of those that must be met by an employee to successfully perform the essential functions of this job.<\/strong><\/p>\n<ul><li>Ability to lift up to 50 lbs.<\/li><li>Standing, walking and stooping throughout the shift.<\/li><li>Ability to keep up with manufacturing requirements.<\/li><li>Ability to meet attendance schedule with dependability and consistency<\/li><li>Ability to use tools and&nbsp;equipment properly and safely.<\/li><li>Ability to lift heavy objects, walk and stand for long periods of time and perform strenuous physical labor under adverse field conditions.<\/li><li>Able to work with dust and outside environment conditions<\/li><li>Used&nbsp;to wearing earplugs and other PPE<\/li><\/ul>","%category%":"Other","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/a2ff730ae081-director-of-quality-control","%breezy_id%":"a2ff730ae081","%breezy_friendly_id%":"a2ff730ae081-director-of-quality-control","%breezy_created_date%":"2025-11-20T16:54:43.595Z","%breezy_updated_date%":"2025-11-20T17:11:24.300Z","%_wpgmp_location_city%":"Houston","%_wpgmp_location_state%":"TX","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Houston, TX, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"29.7600771","%_wpgmp_metabox_longitude%":"-95.3701108","%rank_math_internal_links_processed%":"1"}},"id":2912,"infowindow_disable":false},{"source":"post","title":"Director of Quality Control","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Director of Quality Control\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Our client&nbsp;is&nbsp;looking for a&nbsp;Director of Quality Control&nbsp;who will work alongside Production Operations to ensure the highest level of quality for&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/director-of-quality-control-2\/\" name=\"Director of Quality Control\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Our client&nbsp;is&nbsp;looking for a&nbsp;Director of Quality Control&nbsp;who will work alongside Production Operations to ensure the highest level of quality for&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\/director-of-quality-control-2\/","zoom":19,"extra_fields":{"post_excerpt":"Our client&nbsp;is&nbsp;looking for a&nbsp;Director of Quality Control&nbsp;who will work alongside Production Operations to ensure the highest level of quality for&hellip;","post_content":"<p>Our client&nbsp;is&nbsp;looking for a&nbsp;Director of Quality Control&nbsp;who will work alongside Production Operations to ensure the highest level of quality for their products.&nbsp;By providing leadership and oversight,&nbsp;the&nbsp;Director of Quality Control&nbsp;helps foster a culture of quality within the organization, ensuring that the company's products or services meet or exceed customer expectations.&nbsp;In this role, the&nbsp;Director of Quality Control&nbsp;will work closely with multiple departments across the facility, ensuring that all teams are aware of and adhere to the quality assurance requirements specific to each project.&nbsp;By maintaining a clear focus on safety, environmental compliance, and quality, the&nbsp;Director of Quality Control&nbsp;not only ensures the production of high-quality products but also helps protect employees and the environment, while adhering to all relevant regulations.<\/p>\n<p><strong>Responsibilities<\/strong><\/p>\n<ul><li>Lead&nbsp;and manage the QC team&nbsp;in performing visual inspections of products, ensuring compliance with both internal and client standards.<\/li><li>Develop and deliver quality control training programs to key personnel in collaboration with managers.<\/li><li>Coordinate with managers to implement quality control training programs for key personnel.<\/li><li>Collaborate with&nbsp;senior management&nbsp;teams to resolve quality issues and drive continuous improvement.<\/li><li>Establish, implement, and oversee quality control procedures across all operational areas to maintain consistency and uphold high-quality standards.<\/li><li>Review and approve quality reports, ensuring accuracy and the integrity of data collected during audits and inspections.<\/li><li>Ensure non-conforming products are accurately identified, retained, and handled according to company procedures, preventing their release until compliance is confirmed.<\/li><li>Implement and enforce environment, health, and safety protocols as they relate to the QC&nbsp;function, ensuring compliance with all regulatory standards.<\/li><li>Provide continuous feedback and recommendations to improve processes and enhance quality control measures.<\/li><li>Hold quarterly QC meetings (including Engineering &amp; Production departments) to review quality issues\/concerns<br>&nbsp;<\/li><\/ul>\n<p><strong>Desired Qualifications<\/strong><\/p>\n<ul><li>Knowledge of concrete technology, welding, and nondestructive evaluation\/testing (NDE\/NDT).<\/li><li>ACI certifications.<\/li><li>Understanding and adhere to&nbsp;ASTM, ASSHTO<\/li><\/ul>\n<p>&nbsp;&nbsp;<strong>The physical demands described here are representative of those that must be met by an employee to successfully perform the essential functions of this job.<\/strong><\/p>\n<ul><li>Ability to lift up to 50 lbs.<\/li><li>Standing, walking and stooping throughout the shift.<\/li><li>Ability to keep up with manufacturing requirements.<\/li><li>Ability to meet attendance schedule with dependability and consistency<\/li><li>Ability to use tools and&nbsp;equipment properly and safely.<\/li><li>Ability to lift heavy objects, walk and stand for long periods of time and perform strenuous physical labor under adverse field conditions.<\/li><li>Able to work with dust and outside environment conditions<\/li><li>Used&nbsp;to wearing earplugs and other PPE<\/li><\/ul>","post_title":"Director of Quality Control","post_link":"https:\/\/turnerstaffing.com\/position\/director-of-quality-control-2\/","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%":"High School or Equivalent","%department%":"","%description%":"<p>Our client&nbsp;is&nbsp;looking for a&nbsp;Director of Quality Control&nbsp;who will work alongside Production Operations to ensure the highest level of quality for their products.&nbsp;By providing leadership and oversight,&nbsp;the&nbsp;Director of Quality Control&nbsp;helps foster a culture of quality within the organization, ensuring that the company's products or services meet or exceed customer expectations.&nbsp;In this role, the&nbsp;Director of Quality Control&nbsp;will work closely with multiple departments across the facility, ensuring that all teams are aware of and adhere to the quality assurance requirements specific to each project.&nbsp;By maintaining a clear focus on safety, environmental compliance, and quality, the&nbsp;Director of Quality Control&nbsp;not only ensures the production of high-quality products but also helps protect employees and the environment, while adhering to all relevant regulations.<\/p>\n<p><strong>Responsibilities<\/strong><\/p>\n<ul><li>Lead&nbsp;and manage the QC team&nbsp;in performing visual inspections of products, ensuring compliance with both internal and client standards.<\/li><li>Develop and deliver quality control training programs to key personnel in collaboration with managers.<\/li><li>Coordinate with managers to implement quality control training programs for key personnel.<\/li><li>Collaborate with&nbsp;senior management&nbsp;teams to resolve quality issues and drive continuous improvement.<\/li><li>Establish, implement, and oversee quality control procedures across all operational areas to maintain consistency and uphold high-quality standards.<\/li><li>Review and approve quality reports, ensuring accuracy and the integrity of data collected during audits and inspections.<\/li><li>Ensure non-conforming products are accurately identified, retained, and handled according to company procedures, preventing their release until compliance is confirmed.<\/li><li>Implement and enforce environment, health, and safety protocols as they relate to the QC&nbsp;function, ensuring compliance with all regulatory standards.<\/li><li>Provide continuous feedback and recommendations to improve processes and enhance quality control measures.<\/li><li>Hold quarterly QC meetings (including Engineering &amp; Production departments) to review quality issues\/concerns<br>&nbsp;<\/li><\/ul>\n<p><strong>Desired Qualifications<\/strong><\/p>\n<ul><li>Knowledge of concrete technology, welding, and nondestructive evaluation\/testing (NDE\/NDT).<\/li><li>ACI certifications.<\/li><li>Understanding and adhere to&nbsp;ASTM, ASSHTO<\/li><\/ul>\n<p>&nbsp;&nbsp;<strong>The physical demands described here are representative of those that must be met by an employee to successfully perform the essential functions of this job.<\/strong><\/p>\n<ul><li>Ability to lift up to 50 lbs.<\/li><li>Standing, walking and stooping throughout the shift.<\/li><li>Ability to keep up with manufacturing requirements.<\/li><li>Ability to meet attendance schedule with dependability and consistency<\/li><li>Ability to use tools and&nbsp;equipment properly and safely.<\/li><li>Ability to lift heavy objects, walk and stand for long periods of time and perform strenuous physical labor under adverse field conditions.<\/li><li>Able to work with dust and outside environment conditions<\/li><li>Used&nbsp;to wearing earplugs and other PPE<\/li><\/ul>","%category%":"Other","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/4df7e6284152-director-of-quality-control","%breezy_id%":"4df7e6284152","%breezy_friendly_id%":"4df7e6284152-director-of-quality-control","%breezy_created_date%":"2025-11-20T17:23:05.461Z","%breezy_updated_date%":"2025-11-20T17:23:28.470Z","%_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":2913,"infowindow_disable":false},{"source":"post","title":"Director of Quality Control","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Director of Quality Control\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Our client&nbsp;is&nbsp;looking for a&nbsp;Director of Quality Control&nbsp;who will work alongside Production Operations to ensure the highest level of quality for&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/director-of-quality-control-3\/\" name=\"Director of Quality Control\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Our client&nbsp;is&nbsp;looking for a&nbsp;Director of Quality Control&nbsp;who will work alongside Production Operations to ensure the highest level of quality for&hellip;","address":"Rialto, CA, USA","location":{"lat":"34.1064001","city":"Rialto","state":"CA","country":"United States","lng":"-117.3703235","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/director-of-quality-control-3\/","zoom":19,"extra_fields":{"post_excerpt":"Our client&nbsp;is&nbsp;looking for a&nbsp;Director of Quality Control&nbsp;who will work alongside Production Operations to ensure the highest level of quality for&hellip;","post_content":"<p>Our client&nbsp;is&nbsp;looking for a&nbsp;Director of Quality Control&nbsp;who will work alongside Production Operations to ensure the highest level of quality for their products.&nbsp;By providing leadership and oversight,&nbsp;the&nbsp;Director of Quality Control&nbsp;helps foster a culture of quality within the organization, ensuring that the company's products or services meet or exceed customer expectations.&nbsp;In this role, the&nbsp;Director of Quality Control&nbsp;will work closely with multiple departments across the facility, ensuring that all teams are aware of and adhere to the quality assurance requirements specific to each project.&nbsp;By maintaining a clear focus on safety, environmental compliance, and quality, the&nbsp;Director of Quality Control&nbsp;not only ensures the production of high-quality products but also helps protect employees and the environment, while adhering to all relevant regulations.<\/p>\n<p><strong>Responsibilities<\/strong><\/p>\n<ul><li>Lead&nbsp;and manage the QC team&nbsp;in performing visual inspections of products, ensuring compliance with both internal and client standards.<\/li><li>Develop and deliver quality control training programs to key personnel in collaboration with managers.<\/li><li>Coordinate with managers to implement quality control training programs for key personnel.<\/li><li>Collaborate with&nbsp;senior management&nbsp;teams to resolve quality issues and drive continuous improvement.<\/li><li>Establish, implement, and oversee quality control procedures across all operational areas to maintain consistency and uphold high-quality standards.<\/li><li>Review and approve quality reports, ensuring accuracy and the integrity of data collected during audits and inspections.<\/li><li>Ensure non-conforming products are accurately identified, retained, and handled according to company procedures, preventing their release until compliance is confirmed.<\/li><li>Implement and enforce environment, health, and safety protocols as they relate to the QC&nbsp;function, ensuring compliance with all regulatory standards.<\/li><li>Provide continuous feedback and recommendations to improve processes and enhance quality control measures.<\/li><li>Hold quarterly QC meetings (including Engineering &amp; Production departments) to review quality issues\/concerns<br>&nbsp;<\/li><\/ul>\n<p><strong>Desired Qualifications<\/strong><\/p>\n<ul><li>Knowledge of concrete technology, welding, and nondestructive evaluation\/testing (NDE\/NDT).<\/li><li>ACI certifications.<\/li><li>Understanding and adhere to&nbsp;ASTM, ASSHTO<\/li><\/ul>\n<p>&nbsp;&nbsp;<strong>The physical demands described here are representative of those that must be met by an employee to successfully perform the essential functions of this job.<\/strong><\/p>\n<ul><li>Ability to lift up to 50 lbs.<\/li><li>Standing, walking and stooping throughout the shift.<\/li><li>Ability to keep up with manufacturing requirements.<\/li><li>Ability to meet attendance schedule with dependability and consistency<\/li><li>Ability to use tools and&nbsp;equipment properly and safely.<\/li><li>Ability to lift heavy objects, walk and stand for long periods of time and perform strenuous physical labor under adverse field conditions.<\/li><li>Able to work with dust and outside environment conditions<\/li><li>Used&nbsp;to wearing earplugs and other PPE<\/li><\/ul>","post_title":"Director of Quality Control","post_link":"https:\/\/turnerstaffing.com\/position\/director-of-quality-control-3\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"","%location_country%":"United States","%location_city%":"Rialto","%location_state_id%":"CA","%location_state_name%":"California","%location_city_state%":"Rialto, CA","%education%":"High School or Equivalent","%department%":"","%description%":"<p>Our client&nbsp;is&nbsp;looking for a&nbsp;Director of Quality Control&nbsp;who will work alongside Production Operations to ensure the highest level of quality for their products.&nbsp;By providing leadership and oversight,&nbsp;the&nbsp;Director of Quality Control&nbsp;helps foster a culture of quality within the organization, ensuring that the company's products or services meet or exceed customer expectations.&nbsp;In this role, the&nbsp;Director of Quality Control&nbsp;will work closely with multiple departments across the facility, ensuring that all teams are aware of and adhere to the quality assurance requirements specific to each project.&nbsp;By maintaining a clear focus on safety, environmental compliance, and quality, the&nbsp;Director of Quality Control&nbsp;not only ensures the production of high-quality products but also helps protect employees and the environment, while adhering to all relevant regulations.<\/p>\n<p><strong>Responsibilities<\/strong><\/p>\n<ul><li>Lead&nbsp;and manage the QC team&nbsp;in performing visual inspections of products, ensuring compliance with both internal and client standards.<\/li><li>Develop and deliver quality control training programs to key personnel in collaboration with managers.<\/li><li>Coordinate with managers to implement quality control training programs for key personnel.<\/li><li>Collaborate with&nbsp;senior management&nbsp;teams to resolve quality issues and drive continuous improvement.<\/li><li>Establish, implement, and oversee quality control procedures across all operational areas to maintain consistency and uphold high-quality standards.<\/li><li>Review and approve quality reports, ensuring accuracy and the integrity of data collected during audits and inspections.<\/li><li>Ensure non-conforming products are accurately identified, retained, and handled according to company procedures, preventing their release until compliance is confirmed.<\/li><li>Implement and enforce environment, health, and safety protocols as they relate to the QC&nbsp;function, ensuring compliance with all regulatory standards.<\/li><li>Provide continuous feedback and recommendations to improve processes and enhance quality control measures.<\/li><li>Hold quarterly QC meetings (including Engineering &amp; Production departments) to review quality issues\/concerns<br>&nbsp;<\/li><\/ul>\n<p><strong>Desired Qualifications<\/strong><\/p>\n<ul><li>Knowledge of concrete technology, welding, and nondestructive evaluation\/testing (NDE\/NDT).<\/li><li>ACI certifications.<\/li><li>Understanding and adhere to&nbsp;ASTM, ASSHTO<\/li><\/ul>\n<p>&nbsp;&nbsp;<strong>The physical demands described here are representative of those that must be met by an employee to successfully perform the essential functions of this job.<\/strong><\/p>\n<ul><li>Ability to lift up to 50 lbs.<\/li><li>Standing, walking and stooping throughout the shift.<\/li><li>Ability to keep up with manufacturing requirements.<\/li><li>Ability to meet attendance schedule with dependability and consistency<\/li><li>Ability to use tools and&nbsp;equipment properly and safely.<\/li><li>Ability to lift heavy objects, walk and stand for long periods of time and perform strenuous physical labor under adverse field conditions.<\/li><li>Able to work with dust and outside environment conditions<\/li><li>Used&nbsp;to wearing earplugs and other PPE<\/li><\/ul>","%category%":"Other","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/619153e537e1-director-of-quality-control","%breezy_id%":"619153e537e1","%breezy_friendly_id%":"619153e537e1-director-of-quality-control","%breezy_created_date%":"2025-11-20T17:24:34.320Z","%breezy_updated_date%":"2025-11-20T17:32:44.939Z","%_wpgmp_location_city%":"Rialto","%_wpgmp_location_state%":"CA","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Rialto, CA, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"34.1064001","%_wpgmp_metabox_longitude%":"-117.3703235","%rank_math_internal_links_processed%":"1"}},"id":2914,"infowindow_disable":false},{"source":"post","title":"Class A CDL Driver","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Class A CDL Driver\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Job Title: Class A CDL Driver Location: Charleston, SC Position Overview: We are seeking a dependable and safety-focused Class A&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/class-a-cdl-driver\/\" name=\"Class A CDL Driver\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Job Title: Class A CDL Driver Location: Charleston, SC Position Overview: We are seeking a dependable and safety-focused Class A&hellip;","address":"Charleston, SC, USA","location":{"lat":"32.7833163","city":"Charleston","state":"SC","country":"United States","lng":"-79.9319664","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/class-a-cdl-driver\/","zoom":19,"extra_fields":{"post_excerpt":"Job Title: Class A CDL Driver Location: Charleston, SC Position Overview: We are seeking a dependable and safety-focused Class A&hellip;","post_content":"<p>Job Title: Class A CDL Driver<\/p>\n<p>Location: Charleston, SC<br><\/p>\n\n<p>Position Overview:<\/p>\n<p>We are seeking a dependable and safety-focused Class A CDL Driver to join our team in Charleston, SC. The ideal candidate will have a strong work ethic, solid driving experience, and the ability to operate commercial vehicles in compliance with DOT regulations. This role involves transporting materials\/equipment safely between designated locations while maintaining exceptional customer service and professionalism.<\/p>\n<p>Key Responsibilities:<\/p>\n<p>Safely operate Class A commercial vehicles in accordance with federal, state, and local regulations.<\/p>\n<p>Transport materials, equipment, or goods to and from job sites or specified destinations.<\/p>\n<p>Conduct pre-trip, en-route, and post-trip inspections of vehicles and equipment.<\/p>\n<p>Ensure proper load securement and verify cargo documentation.<\/p>\n<p>Maintain accurate driving logs, delivery records, and required paperwork.<\/p>\n<p>Communicate with dispatch or supervisors regarding schedules, delays, or any issues.<\/p>\n<p>Adhere to company safety policies and participate in safety meetings as required.<\/p>\n<p>Perform basic vehicle maintenance checks and report mechanical concerns immediately.<\/p>\n<p>Qualifications:<\/p>\n<p>Valid Class A Commercial Driver\u2019s License (CDL).<\/p>\n<p>Clean driving record meeting company and DOT requirements.<\/p>\n<p>Minimum of 1\u20132 years of Class A driving experience preferred.<\/p>\n<p>Knowledge of DOT regulations and safe driving practices.<\/p>\n<p>Ability to work outdoors and in varying weather conditions in the Charleston area.<\/p>\n<p>Strong communication and time-management skills.<br><\/p>\n\n\n<p>Physical Requirements:<\/p>\n<p>Ability to lift up to 50 lbs. as needed.<\/p>\n<p>Ability to sit for extended periods while driving.<\/p>\n<p>Ability to climb, bend, or perform tasks related to vehicle inspections and load securement.<\/p>","post_title":"Class A CDL Driver","post_link":"https:\/\/turnerstaffing.com\/position\/class-a-cdl-driver\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Associate","%location_country%":"United States","%location_city%":"Charleston","%location_state_id%":"SC","%location_state_name%":"South Carolina","%location_city_state%":"Charleston, SC","%education%":"","%department%":"","%description%":"<p>Job Title: Class A CDL Driver<\/p>\n<p>Location: Charleston, SC<br><\/p>\n\n<p>Position Overview:<\/p>\n<p>We are seeking a dependable and safety-focused Class A CDL Driver to join our team in Charleston, SC. The ideal candidate will have a strong work ethic, solid driving experience, and the ability to operate commercial vehicles in compliance with DOT regulations. This role involves transporting materials\/equipment safely between designated locations while maintaining exceptional customer service and professionalism.<\/p>\n<p>Key Responsibilities:<\/p>\n<p>Safely operate Class A commercial vehicles in accordance with federal, state, and local regulations.<\/p>\n<p>Transport materials, equipment, or goods to and from job sites or specified destinations.<\/p>\n<p>Conduct pre-trip, en-route, and post-trip inspections of vehicles and equipment.<\/p>\n<p>Ensure proper load securement and verify cargo documentation.<\/p>\n<p>Maintain accurate driving logs, delivery records, and required paperwork.<\/p>\n<p>Communicate with dispatch or supervisors regarding schedules, delays, or any issues.<\/p>\n<p>Adhere to company safety policies and participate in safety meetings as required.<\/p>\n<p>Perform basic vehicle maintenance checks and report mechanical concerns immediately.<\/p>\n<p>Qualifications:<\/p>\n<p>Valid Class A Commercial Driver\u2019s License (CDL).<\/p>\n<p>Clean driving record meeting company and DOT requirements.<\/p>\n<p>Minimum of 1\u20132 years of Class A driving experience preferred.<\/p>\n<p>Knowledge of DOT regulations and safe driving practices.<\/p>\n<p>Ability to work outdoors and in varying weather conditions in the Charleston area.<\/p>\n<p>Strong communication and time-management skills.<br><\/p>\n\n\n<p>Physical Requirements:<\/p>\n<p>Ability to lift up to 50 lbs. as needed.<\/p>\n<p>Ability to sit for extended periods while driving.<\/p>\n<p>Ability to climb, bend, or perform tasks related to vehicle inspections and load securement.<\/p>","%category%":"","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/d4ed1be01f44-class-a-cdl-driver","%breezy_id%":"d4ed1be01f44","%breezy_friendly_id%":"d4ed1be01f44-class-a-cdl-driver","%breezy_created_date%":"2025-11-19T15:14:33.189Z","%breezy_updated_date%":"2025-11-19T15:16:20.028Z","%_wpgmp_location_city%":"Charleston","%_wpgmp_location_state%":"SC","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Charleston, SC, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"32.7833163","%_wpgmp_metabox_longitude%":"-79.9319664","%rank_math_internal_links_processed%":"1"}},"id":2907,"infowindow_disable":false},{"source":"post","title":"Senior Mining Engineer","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Senior Mining Engineer\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Senior Mining Engineer Site Location Sahuarita, Arizona, United States Job Details The Senior Mining Engineer is responsible for developing and&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/senior-mining-engineer\/\" name=\"Senior Mining Engineer\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Senior Mining Engineer Site Location Sahuarita, Arizona, United States Job Details The Senior Mining Engineer is responsible for developing and&hellip;","address":"Sahuarita, AZ, USA","location":{"lat":"31.9575818","city":"Sahuarita","state":"AZ","country":"United States","lng":"-110.955646","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/senior-mining-engineer\/","zoom":19,"extra_fields":{"post_excerpt":"Senior Mining Engineer Site Location Sahuarita, Arizona, United States Job Details The Senior Mining Engineer is responsible for developing and&hellip;","post_content":"<p><u><strong>Senior Mining Engineer<\/strong><\/u><br><\/p>\n\n<p><strong>Site Location<\/strong><\/p>\n<p>Sahuarita, Arizona, United States<\/p>\n<p><strong>Job Details<\/strong><\/p>\n<p>The Senior Mining Engineer is responsible for developing and managing short-, mid-, and long-range mine plans at an open-pit copper operation processing approximately 60,000 tons per day (tpd) of leach material. This role ensures optimized mining sequences, haulage, and leach cycle placements, cost-effective operations, safe working conditions, and efficient leach pad utilization, while mentoring junior staff and coordinating with operational and technical teams.<\/p>\n<p>Key Responsibilities:<\/p>\n<ul>\n <li>Develop      and manage daily and weekly mine plans for material extraction, including      designing, drill &amp; blast sequence, haulage, and leach pad placements.<\/li>\n <li>Monitor      and reconcile operational performance against short-range plans; implement      corrective actions as needed.<\/li>\n <li>Coordinate      closely with operational teams (mining, drilling\/blasting, pad stacking,      metallurgy) to ensure smooth execution of daily plans.<\/li>\n <li>Prepare      rolling monthly and quarterly forecasts, and annual mining budgets      (tonnage, grade, stripping ratios, equipment utilization, and reagent      usage).<\/li>\n <li>Optimize      pit sequencing, leach pad lift designs, haulage routes, and waste      management strategies.<\/li>\n <li>Identify      and recommend operational improvements to increase productivity and cost      efficiency.<\/li>\n <li>Collaborate      with Geotechnical Engineering on slope and dump stability<\/li>\n <li>Model      and steward site water\/acid inventories and solution\u2011management      infrastructure<\/li>\n <li>Generate      and regularly update life-of-mine plans based on evolving pit designs,      geologic models, and economic parameters.<\/li>\n <li>Conduct      pit optimization studies using industry-standard software.<\/li>\n <li>Provide      technical analysis for strategic projects, expansions, and regulatory      filings<\/li>\n <li>Initiate      Kaizen\/LEAN projects that deliver quantified $\/t mined savings<\/li>\n <li>Mentor      and support junior mine planning engineers, facilitating their      professional growth.<\/li>\n <li>Interface      effectively with cross-functional teams, including geology, metallurgy,      Mine Operations, environmental, and safety.<\/li>\n <li>Promote      and enforce high standards of safety and environmental responsibility      across mine planning activities.<\/li>\n<\/ul>\n<p><strong>Requirements<\/strong><\/p>\n<p>Job Requirements:<\/p>\n<ul>\n <li>Education      &amp; Certification: Bachelor\u2019s degree in Mining Engineering<\/li>\n <li>Minimum      5 years' experience in open-pit mining engineering with direct experience      or responsibility for short-, mid-, and long-range mine planning.<\/li>\n <li>Specific      experience in large-scale copper operations utilizing heap or dump leach      processes is highly desirable.<\/li>\n <li>Proficiency      in mine planning software: MineSight\/Hexagon, including Planner, MPSO and      pit optimization tools.<\/li>\n <li>Proficiency      with fleet\u2011management\/dispatch systems and data analytics tools (SQL,      Python, Power\u202fBI)<\/li>\n <li>Strong      knowledge of haulage modeling software<\/li>\n <li>Excellent      analytical and problem-solving abilities with expertise in mine scheduling      and cost optimization.<\/li>\n <li>Strong      interpersonal, leadership, and communication skills; capable of clearly      presenting technical data to various stakeholders.<\/li>\n <li>Comprehensive      understanding of regulatory compliance<\/li>\n <li>Commitment      to a strong safety culture and responsible environmental management      practices.<\/li>\n<\/ul>\n<p>*All employees are subject to annual physical examinations as a condition of employment.<br><\/p>\n<p>\nOur client&nbsp;is an equal opportunity employer. Candidates must possess a current and valid driver\u2019s license. Offers of employment are contingent upon a successful criminal background check and pre-employment physical including a drug screen.<br>\n<\/p>\n<p>Our client&nbsp;offers an excellent low-cost benefits package for medical\/prescription\/ dental\/vision, disability coverage, life insurance and other optional coverage and 401(k) plan with company match.<\/p>\n<p><strong>Pay Type<\/strong><\/p>\n<p>Salaried<\/p>","post_title":"Senior Mining Engineer","post_link":"https:\/\/turnerstaffing.com\/position\/senior-mining-engineer\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Senior","%location_country%":"United States","%location_city%":"Sahuarita","%location_state_id%":"AZ","%location_state_name%":"Arizona","%location_city_state%":"Sahuarita, AZ","%education%":"Bachelor's Degree","%department%":"Engineering","%description%":"<p><u><strong>Senior Mining Engineer<\/strong><\/u><br><\/p>\n\n<p><strong>Site Location<\/strong><\/p>\n<p>Sahuarita, Arizona, United States<\/p>\n<p><strong>Job Details<\/strong><\/p>\n<p>The Senior Mining Engineer is responsible for developing and managing short-, mid-, and long-range mine plans at an open-pit copper operation processing approximately 60,000 tons per day (tpd) of leach material. This role ensures optimized mining sequences, haulage, and leach cycle placements, cost-effective operations, safe working conditions, and efficient leach pad utilization, while mentoring junior staff and coordinating with operational and technical teams.<\/p>\n<p>Key Responsibilities:<\/p>\n<ul>\n <li>Develop      and manage daily and weekly mine plans for material extraction, including      designing, drill &amp; blast sequence, haulage, and leach pad placements.<\/li>\n <li>Monitor      and reconcile operational performance against short-range plans; implement      corrective actions as needed.<\/li>\n <li>Coordinate      closely with operational teams (mining, drilling\/blasting, pad stacking,      metallurgy) to ensure smooth execution of daily plans.<\/li>\n <li>Prepare      rolling monthly and quarterly forecasts, and annual mining budgets      (tonnage, grade, stripping ratios, equipment utilization, and reagent      usage).<\/li>\n <li>Optimize      pit sequencing, leach pad lift designs, haulage routes, and waste      management strategies.<\/li>\n <li>Identify      and recommend operational improvements to increase productivity and cost      efficiency.<\/li>\n <li>Collaborate      with Geotechnical Engineering on slope and dump stability<\/li>\n <li>Model      and steward site water\/acid inventories and solution\u2011management      infrastructure<\/li>\n <li>Generate      and regularly update life-of-mine plans based on evolving pit designs,      geologic models, and economic parameters.<\/li>\n <li>Conduct      pit optimization studies using industry-standard software.<\/li>\n <li>Provide      technical analysis for strategic projects, expansions, and regulatory      filings<\/li>\n <li>Initiate      Kaizen\/LEAN projects that deliver quantified $\/t mined savings<\/li>\n <li>Mentor      and support junior mine planning engineers, facilitating their      professional growth.<\/li>\n <li>Interface      effectively with cross-functional teams, including geology, metallurgy,      Mine Operations, environmental, and safety.<\/li>\n <li>Promote      and enforce high standards of safety and environmental responsibility      across mine planning activities.<\/li>\n<\/ul>\n<p><strong>Requirements<\/strong><\/p>\n<p>Job Requirements:<\/p>\n<ul>\n <li>Education      &amp; Certification: Bachelor\u2019s degree in Mining Engineering<\/li>\n <li>Minimum      5 years' experience in open-pit mining engineering with direct experience      or responsibility for short-, mid-, and long-range mine planning.<\/li>\n <li>Specific      experience in large-scale copper operations utilizing heap or dump leach      processes is highly desirable.<\/li>\n <li>Proficiency      in mine planning software: MineSight\/Hexagon, including Planner, MPSO and      pit optimization tools.<\/li>\n <li>Proficiency      with fleet\u2011management\/dispatch systems and data analytics tools (SQL,      Python, Power\u202fBI)<\/li>\n <li>Strong      knowledge of haulage modeling software<\/li>\n <li>Excellent      analytical and problem-solving abilities with expertise in mine scheduling      and cost optimization.<\/li>\n <li>Strong      interpersonal, leadership, and communication skills; capable of clearly      presenting technical data to various stakeholders.<\/li>\n <li>Comprehensive      understanding of regulatory compliance<\/li>\n <li>Commitment      to a strong safety culture and responsible environmental management      practices.<\/li>\n<\/ul>\n<p>*All employees are subject to annual physical examinations as a condition of employment.<br><\/p>\n<p>\nOur client&nbsp;is an equal opportunity employer. Candidates must possess a current and valid driver\u2019s license. Offers of employment are contingent upon a successful criminal background check and pre-employment physical including a drug screen.<br>\n<\/p>\n<p>Our client&nbsp;offers an excellent low-cost benefits package for medical\/prescription\/ dental\/vision, disability coverage, life insurance and other optional coverage and 401(k) plan with company match.<\/p>\n<p><strong>Pay Type<\/strong><\/p>\n<p>Salaried<\/p>","%category%":"Other","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/53c000a64339-senior-mining-engineer","%breezy_id%":"53c000a64339","%breezy_friendly_id%":"53c000a64339-senior-mining-engineer","%breezy_created_date%":"2025-11-18T14:57:16.173Z","%breezy_updated_date%":"2025-11-18T14:59:27.222Z","%_wpgmp_location_city%":"Sahuarita","%_wpgmp_location_state%":"AZ","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Sahuarita, AZ, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"31.9575818","%_wpgmp_metabox_longitude%":"-110.955646","%rank_math_internal_links_processed%":"1"}},"id":2897,"infowindow_disable":false},{"source":"post","title":"Chief Mining Engineer","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Chief Mining Engineer\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Chief Mining Engineer Site Mission Complex Site Location Sahuarita, Arizona, United States Job Details Position Overview: The Chief Mine Engineer&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/chief-mining-engineer\/\" name=\"Chief Mining Engineer\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Chief Mining Engineer Site Mission Complex Site Location Sahuarita, Arizona, United States Job Details Position Overview: The Chief Mine Engineer&hellip;","address":"Sahuarita, AZ, USA","location":{"lat":"31.9575818","city":"Sahuarita","state":"AZ","country":"United States","lng":"-110.955646","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/chief-mining-engineer\/","zoom":19,"extra_fields":{"post_excerpt":"Chief Mining Engineer Site Mission Complex Site Location Sahuarita, Arizona, United States Job Details Position Overview: The Chief Mine Engineer&hellip;","post_content":"<p><strong>Chief Mining Engineer<\/strong><\/p>\n<p><strong>Site<\/strong><\/p>\n<p>Mission Complex<\/p>\n<p><strong>Site Location<\/strong><\/p>\n<p>Sahuarita, Arizona, United States<\/p>\n<p><strong>Job Details<\/strong><\/p>\n<p><strong>Position Overview:<\/strong><\/p>\n<p>The Chief Mine Engineer is responsible for guiding, coordinating, and overseeing Short Range and Long Range Mine Planning. The Chief Mine Engineer will maintain the quality of mine plans and schedules and monitor the operations' progress. The Senior Mine Engineer is responsible for coordinating and communicating mine plans with operations and other key stakeholders. The Senior Mine Engineer is responsible for evaluating trade-off studies and improving and optimizing Mine design. Must be a leader, and a mentor, willing to work in a fast-paced, dynamic environment, and apply sound engineering knowledge and skills to create solutions to operational challenges and maximize profit.<\/p>\n<p><strong>Essential Functions:<\/strong><\/p>\n<ul>\n <li>Lead      the Mine Planning team in project development, fostering collaboration and      optimizing resources to enhance productivity and safety.<\/li>\n <li>Mentor      and develop skills of other Technical Services staff members.<\/li>\n <li>Develop      strategic mine plans, including 5-year and Life of Mine plans.<\/li>\n <li>Contribute      and assist with Long-Range Planning, including pit optimization, mine      scheduling, fleet sizing, dump designs, technical studies, and asset      optimization.<\/li>\n <li>Assist      and mentor Short Range Planner to establish, execute, and effectively      monitor weekly and monthly plans.<\/li>\n <li>Actively      participate in weekly planning meetings.<\/li>\n <li>Evaluate      methods to optimize ore extraction and mining sequence and prepare      trade-off analyses as required.<\/li>\n <li>Coordinate      mine planning work with geology, dewatering, slope engineering, drill      &amp; blast, and mine operations.<\/li>\n <li>Troubleshoot      problems that arise and frequently inspect open pit; analyze and recommend      solutions.<\/li>\n <li>Responsible      for recognizing mine designs and fleet efficiency issues and implementing      improvements to designs and efficiencies.<\/li>\n <li>Analyze      data and prepare technical memos or presentations to assist in the      decision-making process.<\/li>\n <li>Contribute      to the development of policies and procedures in engineering.<\/li>\n <li>Develop      and manage annual budgets.<\/li>\n <li>Track      actual production and compare progress to the long- and short-range plans.<\/li>\n <li>Assist      with designing and implementing special projects.<\/li>\n <li>Ensure      engineering designs align with industry standards and best practices.<\/li>\n<\/ul>\n<p><strong>Additional Duties:<\/strong><\/p>\n<ul>\n <li>Advanced      knowledge of Hexagon MinePlan software packages.<\/li>\n <li>Proficient      in 3D mining software (Hexagon MinePlan, Whittle), fleet management      systems (Modular Mining Dispatch, ProVision), and databases (acQuire,      Access).<\/li>\n <li>Must      be able to manage time effectively and set priorities.<\/li>\n <li>Strong      leadership skills and ability to create a positive work environment.<\/li>\n <li>Self-motivated      and safety conscious.<\/li>\n <li>Ability      to prioritize multiple tasks and demonstratable project management skills.<\/li>\n <li>Knowledge      of MSHA and State, Environmental, and Safety regulations is beneficial.<\/li>\n <li>Responsible      for executing, supporting, and enforcing the Company's Environmental,      Health, and Safety program as required by OIS policy, directives, and      principles<\/li>\n<\/ul>\n<p><strong>Requirements<\/strong><\/p>\n<p><strong>Required Education and Experience:<\/strong><\/p>\n<ul>\n <li>Requires      seven (10) plus years of directly related open pit Mine Planning and Mine      Operations Experience<\/li>\n <li>A      bachelor\u2019s degree in mining engineering or a related field.<\/li><\/ul>\n<p><strong>Our client is an equal-opportunity employer. Candidates must possess a current and valid driver's license. Offers of employment are contingent upon a successful criminal background check and pre-employment physical including a drug screen.<\/strong><\/p>\n<p><strong>Our client&nbsp;offers an excellent low-cost benefits package for medical\/prescription\/ dental\/vision, disability coverage, life insurance, and other optional coverage, and a 401(k) plan with company match.<\/strong><\/p>\n<p><strong>Pay Type<\/strong><\/p>\n<p>Salaried<\/p>","post_title":"Chief Mining Engineer","post_link":"https:\/\/turnerstaffing.com\/position\/chief-mining-engineer\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Executive","%location_country%":"United States","%location_city%":"Sahuarita","%location_state_id%":"AZ","%location_state_name%":"Arizona","%location_city_state%":"Sahuarita, AZ","%education%":"Bachelor's Degree","%department%":"Engineering","%description%":"<p><strong>Chief Mining Engineer<\/strong><\/p>\n<p><strong>Site<\/strong><\/p>\n<p>Mission Complex<\/p>\n<p><strong>Site Location<\/strong><\/p>\n<p>Sahuarita, Arizona, United States<\/p>\n<p><strong>Job Details<\/strong><\/p>\n<p><strong>Position Overview:<\/strong><\/p>\n<p>The Chief Mine Engineer is responsible for guiding, coordinating, and overseeing Short Range and Long Range Mine Planning. The Chief Mine Engineer will maintain the quality of mine plans and schedules and monitor the operations' progress. The Senior Mine Engineer is responsible for coordinating and communicating mine plans with operations and other key stakeholders. The Senior Mine Engineer is responsible for evaluating trade-off studies and improving and optimizing Mine design. Must be a leader, and a mentor, willing to work in a fast-paced, dynamic environment, and apply sound engineering knowledge and skills to create solutions to operational challenges and maximize profit.<\/p>\n<p><strong>Essential Functions:<\/strong><\/p>\n<ul>\n <li>Lead      the Mine Planning team in project development, fostering collaboration and      optimizing resources to enhance productivity and safety.<\/li>\n <li>Mentor      and develop skills of other Technical Services staff members.<\/li>\n <li>Develop      strategic mine plans, including 5-year and Life of Mine plans.<\/li>\n <li>Contribute      and assist with Long-Range Planning, including pit optimization, mine      scheduling, fleet sizing, dump designs, technical studies, and asset      optimization.<\/li>\n <li>Assist      and mentor Short Range Planner to establish, execute, and effectively      monitor weekly and monthly plans.<\/li>\n <li>Actively      participate in weekly planning meetings.<\/li>\n <li>Evaluate      methods to optimize ore extraction and mining sequence and prepare      trade-off analyses as required.<\/li>\n <li>Coordinate      mine planning work with geology, dewatering, slope engineering, drill      &amp; blast, and mine operations.<\/li>\n <li>Troubleshoot      problems that arise and frequently inspect open pit; analyze and recommend      solutions.<\/li>\n <li>Responsible      for recognizing mine designs and fleet efficiency issues and implementing      improvements to designs and efficiencies.<\/li>\n <li>Analyze      data and prepare technical memos or presentations to assist in the      decision-making process.<\/li>\n <li>Contribute      to the development of policies and procedures in engineering.<\/li>\n <li>Develop      and manage annual budgets.<\/li>\n <li>Track      actual production and compare progress to the long- and short-range plans.<\/li>\n <li>Assist      with designing and implementing special projects.<\/li>\n <li>Ensure      engineering designs align with industry standards and best practices.<\/li>\n<\/ul>\n<p><strong>Additional Duties:<\/strong><\/p>\n<ul>\n <li>Advanced      knowledge of Hexagon MinePlan software packages.<\/li>\n <li>Proficient      in 3D mining software (Hexagon MinePlan, Whittle), fleet management      systems (Modular Mining Dispatch, ProVision), and databases (acQuire,      Access).<\/li>\n <li>Must      be able to manage time effectively and set priorities.<\/li>\n <li>Strong      leadership skills and ability to create a positive work environment.<\/li>\n <li>Self-motivated      and safety conscious.<\/li>\n <li>Ability      to prioritize multiple tasks and demonstratable project management skills.<\/li>\n <li>Knowledge      of MSHA and State, Environmental, and Safety regulations is beneficial.<\/li>\n <li>Responsible      for executing, supporting, and enforcing the Company's Environmental,      Health, and Safety program as required by OIS policy, directives, and      principles<\/li>\n<\/ul>\n<p><strong>Requirements<\/strong><\/p>\n<p><strong>Required Education and Experience:<\/strong><\/p>\n<ul>\n <li>Requires      seven (10) plus years of directly related open pit Mine Planning and Mine      Operations Experience<\/li>\n <li>A      bachelor\u2019s degree in mining engineering or a related field.<\/li><\/ul>\n<p><strong>Our client is an equal-opportunity employer. Candidates must possess a current and valid driver's license. Offers of employment are contingent upon a successful criminal background check and pre-employment physical including a drug screen.<\/strong><\/p>\n<p><strong>Our client&nbsp;offers an excellent low-cost benefits package for medical\/prescription\/ dental\/vision, disability coverage, life insurance, and other optional coverage, and a 401(k) plan with company match.<\/strong><\/p>\n<p><strong>Pay Type<\/strong><\/p>\n<p>Salaried<\/p>","%category%":"Other","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/14cb7b06515a-chief-mining-engineer","%breezy_id%":"14cb7b06515a","%breezy_friendly_id%":"14cb7b06515a-chief-mining-engineer","%breezy_created_date%":"2025-11-18T15:01:46.234Z","%breezy_updated_date%":"2025-11-18T15:02:38.651Z","%_wpgmp_location_city%":"Sahuarita","%_wpgmp_location_state%":"AZ","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Sahuarita, AZ, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"31.9575818","%_wpgmp_metabox_longitude%":"-110.955646","%rank_math_internal_links_processed%":"1"}},"id":2898,"infowindow_disable":false},{"source":"post","title":"General Supervisor &#8211; Electrical","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    General Supervisor &#8211; Electrical\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    ESSENTIAL FUNCTIONS Provide strong safety leadership for the electrical group across all site operations. Understand, apply, and enforce all relevant&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/general-supervisor-electrical\/\" name=\"General Supervisor &#8211; Electrical\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"ESSENTIAL FUNCTIONS Provide strong safety leadership for the electrical group across all site operations. Understand, apply, and enforce all relevant&hellip;","address":"Tucson, AZ, USA","location":{"lat":"32.2539787","city":"Tucson","state":"AZ","country":"United States","lng":"-110.9741769","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/general-supervisor-electrical\/","zoom":19,"extra_fields":{"post_excerpt":"ESSENTIAL FUNCTIONS Provide strong safety leadership for the electrical group across all site operations. Understand, apply, and enforce all relevant&hellip;","post_content":"<h2><strong>ESSENTIAL FUNCTIONS<\/strong><\/h2>\n<ul>\n<li>\n<p>Provide strong safety leadership for the electrical group across all site operations.<\/p>\n<\/li>\n<li>\n<p>Understand, apply, and enforce all relevant federal, state, and local health and safety regulations.<\/p>\n<\/li>\n<li>\n<p>Support environmental compliance across processing facilities and site infrastructure.<\/p>\n<\/li>\n<li>\n<p>Maintain, troubleshoot, and repair all electrical systems on site, including incoming power distribution supporting processing areas and mine-wide operations.<\/p>\n<\/li>\n<li>\n<p>Maintain, troubleshoot, and repair electric mining shovels used for production.<\/p>\n<\/li>\n<li>\n<p>Oversee powerline construction, upgrades, and maintenance activities.<\/p>\n<\/li>\n<li>\n<p>Assist in prioritizing and optimizing electrical, process controls, and communications work across the entire operation.<\/p>\n<\/li>\n<li>\n<p>Order and manage parts, materials, and equipment to ensure uninterrupted production.<\/p>\n<\/li>\n<li>\n<p>Contribute to meeting and sustaining copper cathode output goals.<\/p>\n<\/li>\n<li>\n<p>Support cost-control efforts for both processing and mining departments.<\/p>\n<\/li>\n<li>\n<p>Develop, manage, and refine a comprehensive preventive maintenance program.<\/p>\n<\/li>\n<li>\n<p>Ensure high-quality workmanship, including customer service, procedures, tooling, and personnel performance.<\/p>\n<\/li>\n<li>\n<p>Direct and provide guidance to team members, including process control technicians, the electrical lead, and journeyman\/second-class electricians.<\/p>\n<\/li>\n<li>\n<p>Mentor, train, and develop employees for long-term advancement.<\/p>\n<\/li>\n<li>\n<p>Collaborate closely with processing operations, mining, laboratory, and other departments to improve safety, environmental performance, production efficiency, cost control, and overall quality.<\/p>\n<\/li>\n<li>\n<p>Work cooperatively with union personnel to maintain effective plant and field operations.<\/p>\n<\/li>\n<li>\n<p>Administer company and departmental policies in a consistent and effective manner.<\/p>\n<\/li>\n<li>\n<p>Assist in developing and executing both capital and operational projects aimed at improving plant and site performance.<\/p>\n<\/li>\n<li>\n<p>Serve as backup for the Maintenance Supervisor when required.<\/p>\n<\/li>\n<\/ul>\n<h2><strong>REQUIRED KNOWLEDGE, SKILLS, AND ABILITIES<\/strong><\/h2>\n<ul>\n<li>\n<p>Strong technical foundation in electrical and process control systems, including deep understanding of electrical theory and hands-on experience with AC and DC circuits, motors, and troubleshooting.<\/p>\n<\/li>\n<li>\n<p>Ability to interpret and work from electrical schematics, logic diagrams, and wiring drawings.<\/p>\n<\/li>\n<li>\n<p>Experience with PLC systems, low- and medium-voltage equipment, switchgear, motor controls, and solid-state drive systems.<\/p>\n<\/li>\n<li>\n<p>Demonstrated commitment to world-class safety practices.<\/p>\n<\/li>\n<li>\n<p>Demonstrated commitment to environmental compliance.<\/p>\n<\/li>\n<li>\n<p>Excellent written and verbal communication abilities with staff, peers, and management.<\/p>\n<\/li>\n<li>\n<p>Valid driver\u2019s license required.<\/p>\n<\/li>\n<\/ul>\n<h2><strong>REQUIRED EDUCATION AND EXPERIENCE<\/strong><\/h2>\n<ul>\n<li>\n<p>Minimum of eight (8) years of electrical experience in a mining environment.<\/p>\n<\/li>\n<li>\n<p>Strong computer skills required.<\/p>\n<\/li>\n<li>\n<p>At least five (5) years of supervisory experience.<\/p>\n<\/li>\n<li>\n<p>Bachelor\u2019s degree in Electrical Engineering or a related discipline preferred. Extensive plant and leadership experience (10+ years) may be considered in place of formal education.<\/p><\/li><\/ul>","post_title":"General Supervisor &#8211; Electrical","post_link":"https:\/\/turnerstaffing.com\/position\/general-supervisor-electrical\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"","%location_country%":"United States","%location_city%":"Tucson","%location_state_id%":"AZ","%location_state_name%":"Arizona","%location_city_state%":"Tucson, AZ","%education%":"","%department%":"","%description%":"<h2><strong>ESSENTIAL FUNCTIONS<\/strong><\/h2>\n<ul>\n<li>\n<p>Provide strong safety leadership for the electrical group across all site operations.<\/p>\n<\/li>\n<li>\n<p>Understand, apply, and enforce all relevant federal, state, and local health and safety regulations.<\/p>\n<\/li>\n<li>\n<p>Support environmental compliance across processing facilities and site infrastructure.<\/p>\n<\/li>\n<li>\n<p>Maintain, troubleshoot, and repair all electrical systems on site, including incoming power distribution supporting processing areas and mine-wide operations.<\/p>\n<\/li>\n<li>\n<p>Maintain, troubleshoot, and repair electric mining shovels used for production.<\/p>\n<\/li>\n<li>\n<p>Oversee powerline construction, upgrades, and maintenance activities.<\/p>\n<\/li>\n<li>\n<p>Assist in prioritizing and optimizing electrical, process controls, and communications work across the entire operation.<\/p>\n<\/li>\n<li>\n<p>Order and manage parts, materials, and equipment to ensure uninterrupted production.<\/p>\n<\/li>\n<li>\n<p>Contribute to meeting and sustaining copper cathode output goals.<\/p>\n<\/li>\n<li>\n<p>Support cost-control efforts for both processing and mining departments.<\/p>\n<\/li>\n<li>\n<p>Develop, manage, and refine a comprehensive preventive maintenance program.<\/p>\n<\/li>\n<li>\n<p>Ensure high-quality workmanship, including customer service, procedures, tooling, and personnel performance.<\/p>\n<\/li>\n<li>\n<p>Direct and provide guidance to team members, including process control technicians, the electrical lead, and journeyman\/second-class electricians.<\/p>\n<\/li>\n<li>\n<p>Mentor, train, and develop employees for long-term advancement.<\/p>\n<\/li>\n<li>\n<p>Collaborate closely with processing operations, mining, laboratory, and other departments to improve safety, environmental performance, production efficiency, cost control, and overall quality.<\/p>\n<\/li>\n<li>\n<p>Work cooperatively with union personnel to maintain effective plant and field operations.<\/p>\n<\/li>\n<li>\n<p>Administer company and departmental policies in a consistent and effective manner.<\/p>\n<\/li>\n<li>\n<p>Assist in developing and executing both capital and operational projects aimed at improving plant and site performance.<\/p>\n<\/li>\n<li>\n<p>Serve as backup for the Maintenance Supervisor when required.<\/p>\n<\/li>\n<\/ul>\n<h2><strong>REQUIRED KNOWLEDGE, SKILLS, AND ABILITIES<\/strong><\/h2>\n<ul>\n<li>\n<p>Strong technical foundation in electrical and process control systems, including deep understanding of electrical theory and hands-on experience with AC and DC circuits, motors, and troubleshooting.<\/p>\n<\/li>\n<li>\n<p>Ability to interpret and work from electrical schematics, logic diagrams, and wiring drawings.<\/p>\n<\/li>\n<li>\n<p>Experience with PLC systems, low- and medium-voltage equipment, switchgear, motor controls, and solid-state drive systems.<\/p>\n<\/li>\n<li>\n<p>Demonstrated commitment to world-class safety practices.<\/p>\n<\/li>\n<li>\n<p>Demonstrated commitment to environmental compliance.<\/p>\n<\/li>\n<li>\n<p>Excellent written and verbal communication abilities with staff, peers, and management.<\/p>\n<\/li>\n<li>\n<p>Valid driver\u2019s license required.<\/p>\n<\/li>\n<\/ul>\n<h2><strong>REQUIRED EDUCATION AND EXPERIENCE<\/strong><\/h2>\n<ul>\n<li>\n<p>Minimum of eight (8) years of electrical experience in a mining environment.<\/p>\n<\/li>\n<li>\n<p>Strong computer skills required.<\/p>\n<\/li>\n<li>\n<p>At least five (5) years of supervisory experience.<\/p>\n<\/li>\n<li>\n<p>Bachelor\u2019s degree in Electrical Engineering or a related discipline preferred. Extensive plant and leadership experience (10+ years) may be considered in place of formal education.<\/p><\/li><\/ul>","%category%":"Operations","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/977c59b94f92-general-supervisor-electrical","%breezy_id%":"977c59b94f92","%breezy_friendly_id%":"977c59b94f92-general-supervisor-electrical","%breezy_created_date%":"2025-11-17T16:27:45.517Z","%breezy_updated_date%":"2025-11-17T16:28:58.837Z","%_wpgmp_location_city%":"Tucson","%_wpgmp_location_state%":"AZ","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Tucson, AZ, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"32.2539787","%_wpgmp_metabox_longitude%":"-110.9741769","%rank_math_internal_links_processed%":"1"}},"id":2896,"infowindow_disable":false},{"source":"post","title":"Short-Range Mining Engineer","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Short-Range Mining Engineer\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Position Overview The Short-Range Mining Engineer plays a key role in producing and updating operational mine plans covering timelines from&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/short-range-mining-engineer\/\" name=\"Short-Range Mining Engineer\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Position Overview The Short-Range Mining Engineer plays a key role in producing and updating operational mine plans covering timelines from&hellip;","address":"Superior, AZ, USA","location":{"lat":"33.293945","city":"Superior","state":"AZ","country":"United States","lng":"-111.0962305","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/short-range-mining-engineer\/","zoom":19,"extra_fields":{"post_excerpt":"Position Overview The Short-Range Mining Engineer plays a key role in producing and updating operational mine plans covering timelines from&hellip;","post_content":"<h1><strong>Position Overview<\/strong><\/h1>\n<p>The Short-Range Mining Engineer plays a key role in producing and updating operational mine plans covering timelines from the upcoming month out to one year. This position ensures that short-term designs are practical, geotechnically sound, and aligned with production targets for an open-pit copper operation processing sulfide ore. Working under the direction of the Chief Mining Engineer, the engineer collaborates extensively with Geology, Survey, Processing, and Operations to convert medium-range strategies into actionable bench-level guidance. The role involves preparing dig-ready designs, sequencing pit progression, managing material routing, and supporting daily production execution. Cross-functional development within the broader mine planning group is expected.<\/p>\n<h1><strong>Primary Duties<\/strong><\/h1>\n<ul>\n<li>\n<p>Produce, update, and communicate rolling short-term mine plans (1\u201312 months), ensuring they reflect production priorities, operational conditions, and the mid-range strategic plan.<\/p>\n<\/li>\n<li>\n<p>Create pit advancement designs such as bench configurations, dig polygons, ore boundaries, and drilling layouts that comply with geotechnical, safety, and operational guidelines.<\/p>\n<\/li>\n<li>\n<p>Partner closely with Drill &amp; Blast engineers to develop spacing, burden, timing, and initiation parameters that promote optimal fragmentation, minimize dilution, and support practical field execution.<\/p>\n<\/li>\n<li>\n<p>Coordinate with Mine Geology to integrate grade control interpretations, ore\/waste delineation, and material classifications into daily and weekly dig plans.<\/p>\n<\/li>\n<li>\n<p>Build detailed material movement and routing plans, including directing sulfide ore to the appropriate crushers and stockpile locations while meeting blending and processing specifications.<\/p>\n<\/li>\n<li>\n<p>Prepare operational guidance including haulage instructions, shovel-ready maps, blast clearance diagrams, and related documentation for use by Production and Control Room teams.<\/p>\n<\/li>\n<li>\n<p>Track adherence to the short-range plan by comparing design intent against survey pickups, adjusting schedules and designs to account for ground conditions, equipment utilization, or shifting production needs.<\/p>\n<\/li>\n<li>\n<p>Apply Hexagon MinePlan 3D and related short-term planning tools (e.g., Activity Scheduler, haulage modules) to design, model, visualize, and monitor short-term mining performance.<\/p>\n<\/li>\n<li>\n<p>Participate in routine operational meetings to present progress updates, compliance metrics, and corrective actions for the planning horizon.<\/p>\n<\/li>\n<li>\n<p>Provide inputs to monthly forecasts, budgeting cycles, and reconciliations, ensuring that short-term assumptions and outcomes are accurately captured.<\/p>\n<\/li>\n<li>\n<p>Work alongside Medium-Range and Long-Range Planning teams to support integrated mine scheduling, share feedback on execution, and support cross-training initiatives.<\/p>\n<\/li>\n<li>\n<p>Maintain traceable documentation of assumptions, design changes, schedules, and planning decisions to support transparency, operational learning, and continuous improvement.<\/p>\n<\/li>\n<\/ul>\n<h1><strong>Qualifications<\/strong><\/h1>\n<ul>\n<li>\n<p>Bachelor\u2019s degree in Mining Engineering or a closely aligned discipline.<\/p>\n<\/li>\n<li>\n<p>At least 2 years of professional experience in open-pit mine engineering or mine operations.<\/p>\n<\/li>\n<li>\n<p>Proficiency with Hexagon MinePlan software, including MinePlan 3D, Activity Scheduler, haulage\/scheduling tools, MPSO, and related short-term design applications.<\/p>\n<\/li>\n<li>\n<p>Strong technical understanding of open-pit mining practices, including drilling and blasting, ore control processes, pit sequencing, and material handling.<\/p>\n<\/li>\n<li>\n<p>Ability to work effectively in a dynamic production environment and communicate clearly with both field personnel and technical teams.<\/p>\n<\/li>\n<li>\n<p>Strong analytical abilities coupled with solid communication, organization, and problem-solving skills.<\/p><\/li><\/ul>","post_title":"Short-Range Mining Engineer","post_link":"https:\/\/turnerstaffing.com\/position\/short-range-mining-engineer\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Associate","%location_country%":"United States","%location_city%":"Superior","%location_state_id%":"AZ","%location_state_name%":"Arizona","%location_city_state%":"Superior, AZ","%education%":"Bachelor's Degree","%department%":"","%description%":"<h1><strong>Position Overview<\/strong><\/h1>\n<p>The Short-Range Mining Engineer plays a key role in producing and updating operational mine plans covering timelines from the upcoming month out to one year. This position ensures that short-term designs are practical, geotechnically sound, and aligned with production targets for an open-pit copper operation processing sulfide ore. Working under the direction of the Chief Mining Engineer, the engineer collaborates extensively with Geology, Survey, Processing, and Operations to convert medium-range strategies into actionable bench-level guidance. The role involves preparing dig-ready designs, sequencing pit progression, managing material routing, and supporting daily production execution. Cross-functional development within the broader mine planning group is expected.<\/p>\n<h1><strong>Primary Duties<\/strong><\/h1>\n<ul>\n<li>\n<p>Produce, update, and communicate rolling short-term mine plans (1\u201312 months), ensuring they reflect production priorities, operational conditions, and the mid-range strategic plan.<\/p>\n<\/li>\n<li>\n<p>Create pit advancement designs such as bench configurations, dig polygons, ore boundaries, and drilling layouts that comply with geotechnical, safety, and operational guidelines.<\/p>\n<\/li>\n<li>\n<p>Partner closely with Drill &amp; Blast engineers to develop spacing, burden, timing, and initiation parameters that promote optimal fragmentation, minimize dilution, and support practical field execution.<\/p>\n<\/li>\n<li>\n<p>Coordinate with Mine Geology to integrate grade control interpretations, ore\/waste delineation, and material classifications into daily and weekly dig plans.<\/p>\n<\/li>\n<li>\n<p>Build detailed material movement and routing plans, including directing sulfide ore to the appropriate crushers and stockpile locations while meeting blending and processing specifications.<\/p>\n<\/li>\n<li>\n<p>Prepare operational guidance including haulage instructions, shovel-ready maps, blast clearance diagrams, and related documentation for use by Production and Control Room teams.<\/p>\n<\/li>\n<li>\n<p>Track adherence to the short-range plan by comparing design intent against survey pickups, adjusting schedules and designs to account for ground conditions, equipment utilization, or shifting production needs.<\/p>\n<\/li>\n<li>\n<p>Apply Hexagon MinePlan 3D and related short-term planning tools (e.g., Activity Scheduler, haulage modules) to design, model, visualize, and monitor short-term mining performance.<\/p>\n<\/li>\n<li>\n<p>Participate in routine operational meetings to present progress updates, compliance metrics, and corrective actions for the planning horizon.<\/p>\n<\/li>\n<li>\n<p>Provide inputs to monthly forecasts, budgeting cycles, and reconciliations, ensuring that short-term assumptions and outcomes are accurately captured.<\/p>\n<\/li>\n<li>\n<p>Work alongside Medium-Range and Long-Range Planning teams to support integrated mine scheduling, share feedback on execution, and support cross-training initiatives.<\/p>\n<\/li>\n<li>\n<p>Maintain traceable documentation of assumptions, design changes, schedules, and planning decisions to support transparency, operational learning, and continuous improvement.<\/p>\n<\/li>\n<\/ul>\n<h1><strong>Qualifications<\/strong><\/h1>\n<ul>\n<li>\n<p>Bachelor\u2019s degree in Mining Engineering or a closely aligned discipline.<\/p>\n<\/li>\n<li>\n<p>At least 2 years of professional experience in open-pit mine engineering or mine operations.<\/p>\n<\/li>\n<li>\n<p>Proficiency with Hexagon MinePlan software, including MinePlan 3D, Activity Scheduler, haulage\/scheduling tools, MPSO, and related short-term design applications.<\/p>\n<\/li>\n<li>\n<p>Strong technical understanding of open-pit mining practices, including drilling and blasting, ore control processes, pit sequencing, and material handling.<\/p>\n<\/li>\n<li>\n<p>Ability to work effectively in a dynamic production environment and communicate clearly with both field personnel and technical teams.<\/p>\n<\/li>\n<li>\n<p>Strong analytical abilities coupled with solid communication, organization, and problem-solving skills.<\/p><\/li><\/ul>","%category%":"Operations","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/de28fe5e5e16-short-range-mining-engineer","%breezy_id%":"de28fe5e5e16","%breezy_friendly_id%":"de28fe5e5e16-short-range-mining-engineer","%breezy_created_date%":"2025-11-13T21:34:12.596Z","%breezy_updated_date%":"2025-11-18T15:27:40.984Z","%_wpgmp_location_city%":"Superior","%_wpgmp_location_state%":"AZ","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Superior, AZ, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"33.293945","%_wpgmp_metabox_longitude%":"-111.0962305","%rank_math_internal_links_processed%":"1"}},"id":2893,"infowindow_disable":false},{"source":"post","title":"Maintenance Manager","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Maintenance Manager\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    We are seeking an experienced Maintenance Supervisor to lead and manage all maintenance operations for building systems, including electrical, plumbing,&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/maintenance-manager\/\" name=\"Maintenance Manager\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"We are seeking an experienced Maintenance Supervisor to lead and manage all maintenance operations for building systems, including electrical, plumbing,&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\/maintenance-manager\/","zoom":19,"extra_fields":{"post_excerpt":"We are seeking an experienced Maintenance Supervisor to lead and manage all maintenance operations for building systems, including electrical, plumbing,&hellip;","post_content":"<p>We are seeking an experienced <strong>Maintenance Supervisor<\/strong> to lead and manage all maintenance operations for building systems, including electrical, plumbing, HVAC, painting and&nbsp;carpentry. This role ensures the safety, efficiency, and reliability of our facilities while maintaining strict confidentiality regarding company operations and personnel matters.<\/p>\n<h4><strong>Key Responsibilities<\/strong><\/h4>\n<ul>\n<li>Oversee day-to-day maintenance department operations.<\/li>\n<li>Supervise, hire and coach&nbsp;maintenance staff; determine&nbsp;scheduling&nbsp;and work assignments for the team<\/li>\n<li>Conduct timely and constructive performance evaluations.<\/li>\n<li>Handle disciplinary actions and terminations in compliance with company policy.<\/li>\n<li>Evaluate building systems to identify maintenance needs and plan repairs.<\/li>\n<li>Develop and implement preventive maintenance procedures and schedules.<\/li>\n<li>Ensure all maintenance and repair work is completed accurately and on time.<\/li>\n<li>Assist with departmental budgeting and cost estimation for projects.<\/li>\n<li>Maintain confidentiality in all personnel and operational matters.<\/li>\n<li>Perform other related duties as assigned.<\/li>\n<\/ul>\n<h4><strong>Basic Qualifications<\/strong><\/h4>\n<ul>\n<li>Extensive knowledge of building systems (plumbing, electrical, HVAC).<\/li>\n<li>Licensed Electrician preferred but not required.<\/li>\n<li>Ability to problem solve and have strong analytical&nbsp;skills.<\/li>\n<li>Ability to determine repairs and&nbsp;identify problems<\/li>\n<li>Strong leadership skills&nbsp;<\/li>\n<li>Proficiency in Microsoft Office Suite or similar software.<\/li>\n<li>Forklift and Lockout\/Tagout certification or ability to obtain.<\/li>\n<li>High School Diploma or GED equivalent.<\/li>\n<\/ul>\n<h4><strong>Experience<\/strong><\/h4>\n<ul>\n<li>3+ years of experience with CMMS, EMAINT, or similar maintenance database systems.<\/li>\n<li>Preference of&nbsp;2+ years of experience in procurement processes<\/li><\/ul><p><strong>Work Environment<\/strong><br>&nbsp;\u2022 While performing the duties of this job, the employee is frequently exposed to fumes&nbsp;or airborne particles, moving mechanical parts and vibration. The noise levels can be&nbsp;loud.<\/p><p><strong>Physical Demands<\/strong><\/p><p>&nbsp;\u2022 While performing the duties of this job, the employee is occasionally required to&nbsp;stand; walk; sit; use hands to finger, handle, or feel objects, tools, or controls; reach&nbsp;with hands and arms; climb stairs; talk or hear. The employee must occasionally lift or&nbsp;move products and supplies, up to 75 pounds.<\/p><p><\/p>","post_title":"Maintenance Manager","post_link":"https:\/\/turnerstaffing.com\/position\/maintenance-manager\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Mid Level","%location_country%":"United States","%location_city%":"Dallas","%location_state_id%":"TX","%location_state_name%":"Texas","%location_city_state%":"Dallas, TX","%education%":"High School or Equivalent","%department%":"","%description%":"<p>We are seeking an experienced <strong>Maintenance Supervisor<\/strong> to lead and manage all maintenance operations for building systems, including electrical, plumbing, HVAC, painting and&nbsp;carpentry. This role ensures the safety, efficiency, and reliability of our facilities while maintaining strict confidentiality regarding company operations and personnel matters.<\/p>\n<h4><strong>Key Responsibilities<\/strong><\/h4>\n<ul>\n<li>Oversee day-to-day maintenance department operations.<\/li>\n<li>Supervise, hire and coach&nbsp;maintenance staff; determine&nbsp;scheduling&nbsp;and work assignments for the team<\/li>\n<li>Conduct timely and constructive performance evaluations.<\/li>\n<li>Handle disciplinary actions and terminations in compliance with company policy.<\/li>\n<li>Evaluate building systems to identify maintenance needs and plan repairs.<\/li>\n<li>Develop and implement preventive maintenance procedures and schedules.<\/li>\n<li>Ensure all maintenance and repair work is completed accurately and on time.<\/li>\n<li>Assist with departmental budgeting and cost estimation for projects.<\/li>\n<li>Maintain confidentiality in all personnel and operational matters.<\/li>\n<li>Perform other related duties as assigned.<\/li>\n<\/ul>\n<h4><strong>Basic Qualifications<\/strong><\/h4>\n<ul>\n<li>Extensive knowledge of building systems (plumbing, electrical, HVAC).<\/li>\n<li>Licensed Electrician preferred but not required.<\/li>\n<li>Ability to problem solve and have strong analytical&nbsp;skills.<\/li>\n<li>Ability to determine repairs and&nbsp;identify problems<\/li>\n<li>Strong leadership skills&nbsp;<\/li>\n<li>Proficiency in Microsoft Office Suite or similar software.<\/li>\n<li>Forklift and Lockout\/Tagout certification or ability to obtain.<\/li>\n<li>High School Diploma or GED equivalent.<\/li>\n<\/ul>\n<h4><strong>Experience<\/strong><\/h4>\n<ul>\n<li>3+ years of experience with CMMS, EMAINT, or similar maintenance database systems.<\/li>\n<li>Preference of&nbsp;2+ years of experience in procurement processes<\/li><\/ul><p><strong>Work Environment<\/strong><br>&nbsp;\u2022 While performing the duties of this job, the employee is frequently exposed to fumes&nbsp;or airborne particles, moving mechanical parts and vibration. The noise levels can be&nbsp;loud.<\/p><p><strong>Physical Demands<\/strong><\/p><p>&nbsp;\u2022 While performing the duties of this job, the employee is occasionally required to&nbsp;stand; walk; sit; use hands to finger, handle, or feel objects, tools, or controls; reach&nbsp;with hands and arms; climb stairs; talk or hear. The employee must occasionally lift or&nbsp;move products and supplies, up to 75 pounds.<\/p><p><\/p>","%category%":"Other","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/66b5812bb138-maintenance-manager","%breezy_id%":"66b5812bb138","%breezy_friendly_id%":"66b5812bb138-maintenance-manager","%breezy_created_date%":"2025-11-13T00:15:20.408Z","%breezy_updated_date%":"2025-11-13T00:17:59.122Z","%_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":2891,"infowindow_disable":false},{"source":"post","title":"Grounds Man\/General Laborer","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Grounds Man\/General Laborer\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Job Title: Groundman \/ General Laborer (2\u20133 Month Contract) Location: Chester, SC is one location and the other is Lincolnton,&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/grounds-man-general-laborer\/\" name=\"Grounds Man\/General Laborer\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Job Title: Groundman \/ General Laborer (2\u20133 Month Contract) Location: Chester, SC is one location and the other is Lincolnton,&hellip;","address":"Chester, SC, SC, USA","location":{"lat":"34.7048613","city":"Chester, SC","state":"SC","country":"United States","lng":"-81.2142561","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/grounds-man-general-laborer\/","zoom":19,"extra_fields":{"post_excerpt":"Job Title: Groundman \/ General Laborer (2\u20133 Month Contract) Location: Chester, SC is one location and the other is Lincolnton,&hellip;","post_content":"<p><strong>Job Title:<\/strong> Groundman \/ General Laborer (2\u20133 Month Contract)<\/p>\n<p><strong>Location:<\/strong> Chester, SC is one location and the other is Lincolnton, NC. (They need one person for each location)<\/p>\n<p><strong>Duration:<\/strong> 2\u20133 Months (Contract Position)<\/p>\n<h3><strong>Position Overview<\/strong><\/h3>\n<p>We are seeking a hardworking and safety-conscious <strong>Groundman \/ General Laborer<\/strong> to assist with site operations at our Chester and Hickory, South Carolina project locations. The ideal candidate will have hands-on experience operating chainsaws and other hand tools, with the ability to support daily field activities efficiently and safely. Experience operating track trucks or mini excavators is a <strong>plus<\/strong>, but not required.<\/p>\n<h3><strong>Key Responsibilities<\/strong><\/h3>\n<ul>\n<li>\n<p>Perform general labor duties to support site operations and crews.<\/p>\n<\/li>\n<li>\n<p>Safely operate and maintain chainsaws and other hand tools for clearing, cutting, or ground work.<\/p>\n<\/li>\n<li>\n<p>Assist with loading, unloading, and moving materials and equipment.<\/p>\n<\/li>\n<li>\n<p>Maintain a clean and organized work area.<\/p>\n<\/li>\n<li>\n<p>Follow safety procedures and report any hazards or incidents to the supervisor.<\/p>\n<\/li>\n<li>\n<p>Support equipment operators and crew members as directed.<\/p><\/li>\n<\/ul>\n<h3><strong>Qualifications<\/strong><\/h3>\n<ul>\n<li>\n<p>Previous experience in a general labor, construction, or site support role preferred.<\/p>\n<\/li>\n<li>\n<p>Experience with <strong>chainsaws and other hand tools<\/strong> required.<\/p>\n<\/li>\n<li>\n<p>Experience operating <strong>track trucks or mini excavators<\/strong> is a <strong>plus<\/strong>, but not mandatory.<\/p>\n<\/li>\n<li>\n<p>Ability to perform physically demanding tasks in various weather conditions.<\/p>\n<\/li>\n<li>\n<p>Reliable transportation and punctuality are required.<\/p>\n<\/li>\n<li>\n<p>Must adhere to all company safety policies and procedures<\/p><\/li><\/ul>","post_title":"Grounds Man\/General Laborer","post_link":"https:\/\/turnerstaffing.com\/position\/grounds-man-general-laborer\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Contract","%experience%":"Associate","%location_country%":"United States","%location_city%":"Chester, SC","%location_state_id%":"SC","%location_state_name%":"South Carolina","%location_city_state%":"Chester, SC, SC","%education%":"","%department%":"","%description%":"<p><strong>Job Title:<\/strong> Groundman \/ General Laborer (2\u20133 Month Contract)<\/p>\n<p><strong>Location:<\/strong> Chester, SC is one location and the other is Lincolnton, NC. (They need one person for each location)<\/p>\n<p><strong>Duration:<\/strong> 2\u20133 Months (Contract Position)<\/p>\n<h3><strong>Position Overview<\/strong><\/h3>\n<p>We are seeking a hardworking and safety-conscious <strong>Groundman \/ General Laborer<\/strong> to assist with site operations at our Chester and Hickory, South Carolina project locations. The ideal candidate will have hands-on experience operating chainsaws and other hand tools, with the ability to support daily field activities efficiently and safely. Experience operating track trucks or mini excavators is a <strong>plus<\/strong>, but not required.<\/p>\n<h3><strong>Key Responsibilities<\/strong><\/h3>\n<ul>\n<li>\n<p>Perform general labor duties to support site operations and crews.<\/p>\n<\/li>\n<li>\n<p>Safely operate and maintain chainsaws and other hand tools for clearing, cutting, or ground work.<\/p>\n<\/li>\n<li>\n<p>Assist with loading, unloading, and moving materials and equipment.<\/p>\n<\/li>\n<li>\n<p>Maintain a clean and organized work area.<\/p>\n<\/li>\n<li>\n<p>Follow safety procedures and report any hazards or incidents to the supervisor.<\/p>\n<\/li>\n<li>\n<p>Support equipment operators and crew members as directed.<\/p><\/li>\n<\/ul>\n<h3><strong>Qualifications<\/strong><\/h3>\n<ul>\n<li>\n<p>Previous experience in a general labor, construction, or site support role preferred.<\/p>\n<\/li>\n<li>\n<p>Experience with <strong>chainsaws and other hand tools<\/strong> required.<\/p>\n<\/li>\n<li>\n<p>Experience operating <strong>track trucks or mini excavators<\/strong> is a <strong>plus<\/strong>, but not mandatory.<\/p>\n<\/li>\n<li>\n<p>Ability to perform physically demanding tasks in various weather conditions.<\/p>\n<\/li>\n<li>\n<p>Reliable transportation and punctuality are required.<\/p>\n<\/li>\n<li>\n<p>Must adhere to all company safety policies and procedures<\/p><\/li><\/ul>","%category%":"","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/77084959e4c9-grounds-man-general-laborer","%breezy_id%":"77084959e4c9","%breezy_friendly_id%":"77084959e4c9-grounds-man-general-laborer","%breezy_created_date%":"2025-11-13T18:20:49.168Z","%breezy_updated_date%":"2025-11-17T14:53:09.249Z","%_wpgmp_location_city%":"Chester, SC","%_wpgmp_location_state%":"SC","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Chester, SC, SC, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"34.7048613","%_wpgmp_metabox_longitude%":"-81.2142561","%rank_math_internal_links_processed%":"1"}},"id":2892,"infowindow_disable":false},{"source":"post","title":"Control Systems Engineer- Field Engineering","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Control Systems Engineer- Field Engineering\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    We are looking for an experienced Control Systems Engineer &#8211; Field Engineering&nbsp;to join our growing team. This role is focused&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/control-systems-engineer-field-engineering\/\" name=\"Control Systems Engineer- Field Engineering\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"We are looking for an experienced Control Systems Engineer &#8211; Field Engineering&nbsp;to join our growing team. This role is focused&hellip;","address":"Lakeland, FL, USA","location":{"lat":"28.042093","city":"Lakeland","state":"FL","country":"United States","lng":"-81.9534956","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/control-systems-engineer-field-engineering\/","zoom":19,"extra_fields":{"post_excerpt":"We are looking for an experienced Control Systems Engineer &#8211; Field Engineering&nbsp;to join our growing team. This role is focused&hellip;","post_content":"<p><\/p>\n<p>We are looking for an experienced Control Systems Engineer - Field Engineering&nbsp;to join our growing team. This role is focused on the design, configuration, testing, and commissioning of AC and DC drive systems, PLC\/HMI automation systems, and rotating machinery. You will work closely with senior engineers and project managers to deliver safe, efficient, and innovative solutions across industries such as mining, metals, plastics, utilities, and manufacturing.<\/p>\n<p>This is a hands-on engineering position that combines technical expertise, problem-solving, and fieldwork. You will have opportunities to contribute to a wide variety of projects, from small system upgrades to large-scale automation deployments.<\/p>\n<h3>What You\u2019ll Do<\/h3>\n<ul>\n<li>\n<p>Support end-to-end projects involving AC and DC drives, PLCs, HMIs, and automation systems.<\/p>\n<\/li>\n<li>\n<p>Assist in the design, assembly, programming, testing, and commissioning of new and upgraded systems.<\/p>\n<\/li>\n<li>\n<p>Program and configure PLCs (Siemens, Allen-Bradley) using multiple languages including Ladder Logic, Structured Text, and Function Block Diagram.<\/p>\n<\/li>\n<li>\n<p>Develop and configure HMI operator interfaces for process monitoring, alarms, and operator control.<\/p>\n<\/li>\n<li>\n<p>Work on drive applications including speed and torque control, PID process loops (pressure, temperature, flow, speed), hoists, winders, and pump\/fan control systems.<\/p>\n<\/li>\n<li>\n<p>Integrate industrial communication protocols such as Modbus TCP\/RTU, Profibus, Profinet, and EtherNet\/IP.<\/p>\n<\/li>\n<li>\n<p>Collaborate with project managers, vendors, and customers to meet project specifications, delivery deadlines, and commissioning schedules.<\/p>\n<\/li>\n<li>\n<p>Participate in on-site installation, testing, troubleshooting, and customer training\/support.<\/p>\n<\/li>\n<li>\n<p>Follow established engineering best practices, industry standards (UL, NFPA), and company safety procedures.<\/p>\n<\/li>\n<li>\n<p>Progress toward independent project ownership as knowledge and experience grow.<\/p>\n<\/li>\n<\/ul>\n<h3>What We\u2019re Looking For<\/h3>\n<ul>\n<li>\n<p>Bachelor\u2019s degree in Electrical Engineering or Engineering Technology.<\/p>\n<\/li>\n<li>\n<p>5\u20137 years of relevant control systems engineering experience.<\/p>\n<\/li>\n<li>\n<p>Strong hands-on background with AC\/DC drives, PLCs, HMIs, and rotating machinery.<\/p>\n<\/li>\n<li>\n<p>Experience with Siemens S7 family (S7-1500, S7-1200) and Allen-Bradley ControlLogix, CompactLogix, and MicroLogix platforms.<\/p>\n<\/li>\n<li>\n<p>Familiarity with SCADA systems such as Wonderware or Ignition (preferred).<\/p>\n<\/li>\n<li>\n<p>Experience with control loop design and PID loop tuning.<\/p>\n<\/li>\n<li>\n<p>Knowledge of industrial electrical design standards (UL, NFPA).<\/p>\n<\/li>\n<li>\n<p>Strong troubleshooting and critical thinking skills, with the ability to diagnose and resolve issues in the field.<\/p>\n<\/li>\n<li>\n<p>Excellent communication and organizational skills; ability to manage multiple priorities in a fast-paced environment.<\/p>\n<\/li>\n<li>\n<p>Proficiency with Microsoft Office and standard engineering tools.<\/p>\n<\/li>\n<li>\n<p>Willingness to travel overnight as needed for project work and commissioning.<\/p>\n<\/li>\n<\/ul>\n<h3>Why Join Us<\/h3>\n<ul>\n<li>\n<p>Diverse projects: Contribute to automation and control solutions across multiple industries.<\/p>\n<\/li>\n<li>\n<p>Professional growth: Progress from shadowing senior engineers to leading independent projects.<\/p>\n<\/li>\n<li>\n<p>Innovation culture: Be part of a team that values safety, teamwork, continuous improvement, and technical excellence.<\/p>\n<\/li>\n<li>\n<p>Customer impact: Work directly with clients to deliver mission-critical solutions that improve performance and reliability.<\/p>\n<\/li>\n<\/ul>\n<p>If you are a motivated Control Systems Engineer who thrives in challenging, hands-on environments and enjoys working on complex automation projects, we\u2019d love to hear from you.<\/p>\n<p><\/p>","post_title":"Control Systems Engineer- Field Engineering","post_link":"https:\/\/turnerstaffing.com\/position\/control-systems-engineer-field-engineering\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Mid Level","%location_country%":"United States","%location_city%":"Lakeland","%location_state_id%":"FL","%location_state_name%":"Florida","%location_city_state%":"Lakeland, FL","%education%":"Bachelor's Degree","%department%":"","%description%":"<p><\/p>\n<p>We are looking for an experienced Control Systems Engineer - Field Engineering&nbsp;to join our growing team. This role is focused on the design, configuration, testing, and commissioning of AC and DC drive systems, PLC\/HMI automation systems, and rotating machinery. You will work closely with senior engineers and project managers to deliver safe, efficient, and innovative solutions across industries such as mining, metals, plastics, utilities, and manufacturing.<\/p>\n<p>This is a hands-on engineering position that combines technical expertise, problem-solving, and fieldwork. You will have opportunities to contribute to a wide variety of projects, from small system upgrades to large-scale automation deployments.<\/p>\n<h3>What You\u2019ll Do<\/h3>\n<ul>\n<li>\n<p>Support end-to-end projects involving AC and DC drives, PLCs, HMIs, and automation systems.<\/p>\n<\/li>\n<li>\n<p>Assist in the design, assembly, programming, testing, and commissioning of new and upgraded systems.<\/p>\n<\/li>\n<li>\n<p>Program and configure PLCs (Siemens, Allen-Bradley) using multiple languages including Ladder Logic, Structured Text, and Function Block Diagram.<\/p>\n<\/li>\n<li>\n<p>Develop and configure HMI operator interfaces for process monitoring, alarms, and operator control.<\/p>\n<\/li>\n<li>\n<p>Work on drive applications including speed and torque control, PID process loops (pressure, temperature, flow, speed), hoists, winders, and pump\/fan control systems.<\/p>\n<\/li>\n<li>\n<p>Integrate industrial communication protocols such as Modbus TCP\/RTU, Profibus, Profinet, and EtherNet\/IP.<\/p>\n<\/li>\n<li>\n<p>Collaborate with project managers, vendors, and customers to meet project specifications, delivery deadlines, and commissioning schedules.<\/p>\n<\/li>\n<li>\n<p>Participate in on-site installation, testing, troubleshooting, and customer training\/support.<\/p>\n<\/li>\n<li>\n<p>Follow established engineering best practices, industry standards (UL, NFPA), and company safety procedures.<\/p>\n<\/li>\n<li>\n<p>Progress toward independent project ownership as knowledge and experience grow.<\/p>\n<\/li>\n<\/ul>\n<h3>What We\u2019re Looking For<\/h3>\n<ul>\n<li>\n<p>Bachelor\u2019s degree in Electrical Engineering or Engineering Technology.<\/p>\n<\/li>\n<li>\n<p>5\u20137 years of relevant control systems engineering experience.<\/p>\n<\/li>\n<li>\n<p>Strong hands-on background with AC\/DC drives, PLCs, HMIs, and rotating machinery.<\/p>\n<\/li>\n<li>\n<p>Experience with Siemens S7 family (S7-1500, S7-1200) and Allen-Bradley ControlLogix, CompactLogix, and MicroLogix platforms.<\/p>\n<\/li>\n<li>\n<p>Familiarity with SCADA systems such as Wonderware or Ignition (preferred).<\/p>\n<\/li>\n<li>\n<p>Experience with control loop design and PID loop tuning.<\/p>\n<\/li>\n<li>\n<p>Knowledge of industrial electrical design standards (UL, NFPA).<\/p>\n<\/li>\n<li>\n<p>Strong troubleshooting and critical thinking skills, with the ability to diagnose and resolve issues in the field.<\/p>\n<\/li>\n<li>\n<p>Excellent communication and organizational skills; ability to manage multiple priorities in a fast-paced environment.<\/p>\n<\/li>\n<li>\n<p>Proficiency with Microsoft Office and standard engineering tools.<\/p>\n<\/li>\n<li>\n<p>Willingness to travel overnight as needed for project work and commissioning.<\/p>\n<\/li>\n<\/ul>\n<h3>Why Join Us<\/h3>\n<ul>\n<li>\n<p>Diverse projects: Contribute to automation and control solutions across multiple industries.<\/p>\n<\/li>\n<li>\n<p>Professional growth: Progress from shadowing senior engineers to leading independent projects.<\/p>\n<\/li>\n<li>\n<p>Innovation culture: Be part of a team that values safety, teamwork, continuous improvement, and technical excellence.<\/p>\n<\/li>\n<li>\n<p>Customer impact: Work directly with clients to deliver mission-critical solutions that improve performance and reliability.<\/p>\n<\/li>\n<\/ul>\n<p>If you are a motivated Control Systems Engineer who thrives in challenging, hands-on environments and enjoys working on complex automation projects, we\u2019d love to hear from you.<\/p>\n<p><\/p>","%category%":"Operations","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/5210b5232852-control-systems-engineer-field-engineering","%breezy_id%":"5210b5232852","%breezy_friendly_id%":"5210b5232852-control-systems-engineer-field-engineering","%breezy_created_date%":"2025-09-25T19:35:43.515Z","%breezy_updated_date%":"2026-01-14T19:06:57.129Z","%_wpgmp_location_city%":"Lakeland","%_wpgmp_location_state%":"FL","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Lakeland, FL, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"28.042093","%_wpgmp_metabox_longitude%":"-81.9534956","%rank_math_internal_links_processed%":"1"}},"id":2871,"infowindow_disable":false},{"source":"post","title":"Fabricator I-IV","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Fabricator I-IV\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Fabricator I-IV Position Overview The fabricator is responsible for the fabrication of handrails, walkways, decks, drill tooling, and support equipment.&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/fabricator-i-iv\/\" name=\"Fabricator I-IV\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Fabricator I-IV Position Overview The fabricator is responsible for the fabrication of handrails, walkways, decks, drill tooling, and support equipment.&hellip;","address":"Phoenix, AZ, USA","location":{"lat":"33.4482948","city":"Phoenix","state":"AZ","country":"United States","lng":"-112.0725488","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/fabricator-i-iv\/","zoom":19,"extra_fields":{"post_excerpt":"Fabricator I-IV Position Overview The fabricator is responsible for the fabrication of handrails, walkways, decks, drill tooling, and support equipment.&hellip;","post_content":"<h1><strong>Fabricator I-IV<\/strong><\/h1>\n<h1>Position Overview<\/h1>\n<p>The fabricator is responsible for the fabrication of handrails, walkways, decks, drill tooling, and support equipment. Weld casing and other fabrication as needed both in the shop and within the field.<br><\/p>\n<ul><li>Fabricators can work 10 days on 4 days off, 9 days on 5 days off, or 8 days on 6 days off schedule. &nbsp;<\/li><\/ul>\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. <\/li><li>Maintain effective and collaborative workplace relationships, treating others with dignity and respect.<\/li><\/ul>\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. <\/li><li>Must have a valid driver's license and can obtain a CDL. <\/li><li>Field mechanics must have the ability to work 12 hours per day plus travel time, to and from the rig, and work in extreme weather conditions in geographically isolated areas.<\/li><li>Must have experience with MIG, TIG, and ARC welding.<\/li><li>Must know how to use a CNC plasma table.<\/li><li>Must understand how to read a print.<\/li><li>Experience repairing and maintaining mechanical equipment.<\/li><li>Must be able to lift 100 lbs. <\/li><li>Must be able to stand for long periods of time and push, pull, reach, climb, bend, twist, squat, and kneel multiple times per shift.<\/li><li>Must be willing to travel and work in remote locations, outside, and in all weather conditions (heat and cold).<\/li><\/ul>","post_title":"Fabricator I-IV","post_link":"https:\/\/turnerstaffing.com\/position\/fabricator-i-iv\/","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><strong>Fabricator I-IV<\/strong><\/h1>\n<h1>Position Overview<\/h1>\n<p>The fabricator is responsible for the fabrication of handrails, walkways, decks, drill tooling, and support equipment. Weld casing and other fabrication as needed both in the shop and within the field.<br><\/p>\n<ul><li>Fabricators can work 10 days on 4 days off, 9 days on 5 days off, or 8 days on 6 days off schedule. &nbsp;<\/li><\/ul>\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. <\/li><li>Maintain effective and collaborative workplace relationships, treating others with dignity and respect.<\/li><\/ul>\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. <\/li><li>Must have a valid driver's license and can obtain a CDL. <\/li><li>Field mechanics must have the ability to work 12 hours per day plus travel time, to and from the rig, and work in extreme weather conditions in geographically isolated areas.<\/li><li>Must have experience with MIG, TIG, and ARC welding.<\/li><li>Must know how to use a CNC plasma table.<\/li><li>Must understand how to read a print.<\/li><li>Experience repairing and maintaining mechanical equipment.<\/li><li>Must be able to lift 100 lbs. <\/li><li>Must be able to stand for long periods of time and push, pull, reach, climb, bend, twist, squat, and kneel multiple times per shift.<\/li><li>Must be willing to travel and work in remote locations, outside, and in all weather conditions (heat and cold).<\/li><\/ul>","%category%":"","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/082d6498ac80-fabricator-i-iv","%breezy_id%":"082d6498ac80","%breezy_friendly_id%":"082d6498ac80-fabricator-i-iv","%breezy_created_date%":"2025-04-02T03:48:06.470Z","%breezy_updated_date%":"2025-11-14T20:41:08.721Z","%_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.4482948","%_wpgmp_metabox_longitude%":"-112.0725488","%rank_math_internal_links_processed%":"1"}},"id":2868,"infowindow_disable":false},{"source":"post","title":"Project Engineer\/Estimator","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Project Engineer\/Estimator\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Project Manager\/ Bid Engineer Builds thorough project plans that account for work schedules, productivities, asset utilization, and personnel deployment. Reports&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/project-engineer-estimator\/\" name=\"Project Engineer\/Estimator\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Project Manager\/ Bid Engineer Builds thorough project plans that account for work schedules, productivities, asset utilization, and personnel deployment. Reports&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\/project-engineer-estimator\/","zoom":19,"extra_fields":{"post_excerpt":"Project Manager\/ Bid Engineer Builds thorough project plans that account for work schedules, productivities, asset utilization, and personnel deployment. Reports&hellip;","post_content":"<p><strong><u>Project Manager\/ Bid Engineer<\/u><\/strong><\/p>\n<p>Builds thorough project plans that account for work schedules, productivities, asset utilization, and personnel deployment.<\/p>\n<p>Reports to Chief of Staff<\/p>\n<p><strong><u>Bid Preparation<\/u><\/strong><\/p>\n<p>\u2022\tFile new opportunities in TMG\u2019s database for all required information for internal communications<\/p>\n<p>\u2022\tComplete quantity take-offs to display total project scope to Bid Team and Operations Team<\/p>\n<p>\u2022\tDraft project description for internal review of project requirements. Include: timeline restrictions, key scope elements, highlighted risk, and key owner\/ site details.<\/p>\n<p>\u2022\tHighlight requirements for external vendors, subcontractors, and material providers<\/p>\n<p>\u2022\tAttend the Operational Approach meeting to design a strategic plan for the project<\/p>\n<p>\u2022\tDistribute qualification forms and safety requirements to staff for bid submissions&nbsp;<\/p><p><u><strong>Project Modeling<\/strong><\/u><\/p>\n<p>\u2022\tDraft a comprehensive project model using the scope documents sent by clients.<\/p>\n<p>\u2022\tCommunicate with clients to acquire information needed to complete an accurate project plan<\/p>\n<p>\u2022\tWork with TMG procurement department to run RFQ processes for subcontractor, vendor, and materials quotes.<\/p>\n<p>\u2022\tOptimize productivities and crew layout to achieve lowest possible cost to perform work<\/p>\n<p>\u2022\tModel crew schedules to optimize overtime, headcount, and total labor hours<\/p>\n<p>\u2022\tCreate key metrics for equipment rate calculations (utilization, terms for equipment schedules)<\/p>\n<p>\u2022\tProduce a final report for inputs into estimation software (complete template for each estimate)&nbsp;<\/p><p><u><strong>Estimate Review\/ Proposal Construction<\/strong><\/u><\/p>\n<p>\u2022\tConstruct project cashflow models accounting for contracted pay terms for client invoicing, vendor pay terms for financing, subcontractors, and materials.<\/p>\n<p>\u2022\tPresent project schedule assumptions for mobilization, activity completion, weather\/ delays, blasting, material deliveries, and other critical path items.<\/p>\n<p>\u2022\tReport equipment budget assumptions for utilization metrics and duration of deployments<\/p>\n<p>\u2022\tReport productivity assumptions based on historical data and scope specifications<\/p>\n<p>\u2022\tAssemble full list of clarifications and assumptions for project proposals<\/p>\n<p>\u2022\tAnswer all owner required questions and clarifications in the proposal<\/p>\n<p>\u2022\tAssemble required bid attachments such as time and material rates and required bid tables for submission<\/p>\n<p><strong><u>Proficiencies<\/u><\/strong><\/p>\n<p>Project Management, Project Reporting, Accounting, Financial Reporting, Purchasing, Email, Word, Excel, PowerPoint, Forecasting, Budgeting, Personnel Development,<\/p>","post_title":"Project Engineer\/Estimator","post_link":"https:\/\/turnerstaffing.com\/position\/project-engineer-estimator\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Mid Level","%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%":"Operations","%description%":"<p><strong><u>Project Manager\/ Bid Engineer<\/u><\/strong><\/p>\n<p>Builds thorough project plans that account for work schedules, productivities, asset utilization, and personnel deployment.<\/p>\n<p>Reports to Chief of Staff<\/p>\n<p><strong><u>Bid Preparation<\/u><\/strong><\/p>\n<p>\u2022\tFile new opportunities in TMG\u2019s database for all required information for internal communications<\/p>\n<p>\u2022\tComplete quantity take-offs to display total project scope to Bid Team and Operations Team<\/p>\n<p>\u2022\tDraft project description for internal review of project requirements. Include: timeline restrictions, key scope elements, highlighted risk, and key owner\/ site details.<\/p>\n<p>\u2022\tHighlight requirements for external vendors, subcontractors, and material providers<\/p>\n<p>\u2022\tAttend the Operational Approach meeting to design a strategic plan for the project<\/p>\n<p>\u2022\tDistribute qualification forms and safety requirements to staff for bid submissions&nbsp;<\/p><p><u><strong>Project Modeling<\/strong><\/u><\/p>\n<p>\u2022\tDraft a comprehensive project model using the scope documents sent by clients.<\/p>\n<p>\u2022\tCommunicate with clients to acquire information needed to complete an accurate project plan<\/p>\n<p>\u2022\tWork with TMG procurement department to run RFQ processes for subcontractor, vendor, and materials quotes.<\/p>\n<p>\u2022\tOptimize productivities and crew layout to achieve lowest possible cost to perform work<\/p>\n<p>\u2022\tModel crew schedules to optimize overtime, headcount, and total labor hours<\/p>\n<p>\u2022\tCreate key metrics for equipment rate calculations (utilization, terms for equipment schedules)<\/p>\n<p>\u2022\tProduce a final report for inputs into estimation software (complete template for each estimate)&nbsp;<\/p><p><u><strong>Estimate Review\/ Proposal Construction<\/strong><\/u><\/p>\n<p>\u2022\tConstruct project cashflow models accounting for contracted pay terms for client invoicing, vendor pay terms for financing, subcontractors, and materials.<\/p>\n<p>\u2022\tPresent project schedule assumptions for mobilization, activity completion, weather\/ delays, blasting, material deliveries, and other critical path items.<\/p>\n<p>\u2022\tReport equipment budget assumptions for utilization metrics and duration of deployments<\/p>\n<p>\u2022\tReport productivity assumptions based on historical data and scope specifications<\/p>\n<p>\u2022\tAssemble full list of clarifications and assumptions for project proposals<\/p>\n<p>\u2022\tAnswer all owner required questions and clarifications in the proposal<\/p>\n<p>\u2022\tAssemble required bid attachments such as time and material rates and required bid tables for submission<\/p>\n<p><strong><u>Proficiencies<\/u><\/strong><\/p>\n<p>Project Management, Project Reporting, Accounting, Financial Reporting, Purchasing, Email, Word, Excel, PowerPoint, Forecasting, Budgeting, Personnel Development,<\/p>","%category%":"Operations","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/a54bb7e58e43-project-engineer-estimator","%breezy_id%":"a54bb7e58e43","%breezy_friendly_id%":"a54bb7e58e43-project-engineer-estimator","%breezy_created_date%":"2024-08-28T17:37:00.937Z","%breezy_updated_date%":"2025-11-03T16:35:17.455Z","%_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":2862,"infowindow_disable":false},{"source":"post","title":"Chief Estimator","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Chief Estimator\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    The Chief Estimator will oversee all activities in the estimation process, ensuring that projects are accurately estimated, risks are identified,&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/chief-estimator-2\/\" name=\"Chief Estimator\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"The Chief Estimator will oversee all activities in the estimation process, ensuring that projects are accurately estimated, risks are identified,&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\/chief-estimator-2\/","zoom":19,"extra_fields":{"post_excerpt":"The Chief Estimator will oversee all activities in the estimation process, ensuring that projects are accurately estimated, risks are identified,&hellip;","post_content":"<p>The Chief Estimator will oversee all activities in the estimation process, ensuring that projects are accurately estimated,<\/p>\n<p>risks are identified, and all operational aspects are prepared for successful project execution. This senior role involves<\/p>\n<p>close collaboration with various departments to ensure a seamless transition from planning to execution.<\/p>\n<p><strong><br><\/strong><\/p><p><strong>Reports to President<\/strong><\/p>\n<p><strong><br><\/strong><\/p><p><strong>Bid Strategy Development<\/strong><\/p>\n<ul><li>Oversee and guide the entire estimation process, ensuring all estimates are precise and comprehensive.<\/li><li>Develop and implement high-level strategies to create competitive and compelling bids that align with Turner Mining Group\u2019s business objectives.<\/li><li>Evaluate market trends and competitor strategies to identify opportunities for differentiation and competitive advantage.<\/li><li>Foster strong relationships with clients and stakeholders to understand their needs and position Turner Mining Group as the preferred contractor.<\/li><li>Collaborate with senior leadership to align bid strategies with overall company goals and financial targets.<\/li><\/ul><p><\/p>\n<p><strong>Internal Process Management<\/strong><\/p><ul><li>Ensure all operational aspects are prepared for project execution, including resource allocation and scheduling, by developing and implementing streamlined processes.<\/li><li>Oversee risk management strategies, identifying potential risks early and developing robust mitigation plans.<\/li><li>Collaborate with cross-functional teams including operations, finance, asset management, and human resources to ensure cohesive and efficient project planning and execution.<\/li><li>Lead and mentor the estimating team, fostering a culture of continuous improvement and professional development.<\/li><\/ul>\n<p><strong><br><\/strong><\/p><p><strong>Data Management<\/strong><\/p>\n<ul><li>Ensure compliance with client specifications and company policies by establishing and maintaining standards for all estimation activities and documentation.<\/li><li>Develop and implement systems for maintaining detailed and accurate records of all estimation activities, including assumptions, methodologies, and decision-making processes.<\/li><li>Present cost estimates and strategic insights to the Operational Leadership Team, highlighting key differentiators of Turner Mining Group\u2019s proposals.<\/li><li>Drive continuous improvement by implementing feedback and lessons learned into future estimation processes.<\/li><li>Utilize data analytics to identify new business opportunities and potential markets, developing strategic plans to pursue them.<\/li><\/ul>\n<p><strong><br><\/strong><\/p><p><strong>Proficiencies<\/strong><\/p>\n<ul><li>Project Management, Accounting, Email, Word, Excel, PowerPoint, Budgeting, Forecasting, HCSS HeavyBid, HCSS HeavyJob, Primavera P6.<\/li><\/ul>","post_title":"Chief Estimator","post_link":"https:\/\/turnerstaffing.com\/position\/chief-estimator-2\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Senior","%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%":"","%description%":"<p>The Chief Estimator will oversee all activities in the estimation process, ensuring that projects are accurately estimated,<\/p>\n<p>risks are identified, and all operational aspects are prepared for successful project execution. This senior role involves<\/p>\n<p>close collaboration with various departments to ensure a seamless transition from planning to execution.<\/p>\n<p><strong><br><\/strong><\/p><p><strong>Reports to President<\/strong><\/p>\n<p><strong><br><\/strong><\/p><p><strong>Bid Strategy Development<\/strong><\/p>\n<ul><li>Oversee and guide the entire estimation process, ensuring all estimates are precise and comprehensive.<\/li><li>Develop and implement high-level strategies to create competitive and compelling bids that align with Turner Mining Group\u2019s business objectives.<\/li><li>Evaluate market trends and competitor strategies to identify opportunities for differentiation and competitive advantage.<\/li><li>Foster strong relationships with clients and stakeholders to understand their needs and position Turner Mining Group as the preferred contractor.<\/li><li>Collaborate with senior leadership to align bid strategies with overall company goals and financial targets.<\/li><\/ul><p><\/p>\n<p><strong>Internal Process Management<\/strong><\/p><ul><li>Ensure all operational aspects are prepared for project execution, including resource allocation and scheduling, by developing and implementing streamlined processes.<\/li><li>Oversee risk management strategies, identifying potential risks early and developing robust mitigation plans.<\/li><li>Collaborate with cross-functional teams including operations, finance, asset management, and human resources to ensure cohesive and efficient project planning and execution.<\/li><li>Lead and mentor the estimating team, fostering a culture of continuous improvement and professional development.<\/li><\/ul>\n<p><strong><br><\/strong><\/p><p><strong>Data Management<\/strong><\/p>\n<ul><li>Ensure compliance with client specifications and company policies by establishing and maintaining standards for all estimation activities and documentation.<\/li><li>Develop and implement systems for maintaining detailed and accurate records of all estimation activities, including assumptions, methodologies, and decision-making processes.<\/li><li>Present cost estimates and strategic insights to the Operational Leadership Team, highlighting key differentiators of Turner Mining Group\u2019s proposals.<\/li><li>Drive continuous improvement by implementing feedback and lessons learned into future estimation processes.<\/li><li>Utilize data analytics to identify new business opportunities and potential markets, developing strategic plans to pursue them.<\/li><\/ul>\n<p><strong><br><\/strong><\/p><p><strong>Proficiencies<\/strong><\/p>\n<ul><li>Project Management, Accounting, Email, Word, Excel, PowerPoint, Budgeting, Forecasting, HCSS HeavyBid, HCSS HeavyJob, Primavera P6.<\/li><\/ul>","%category%":"","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/fc64a49c836c-chief-estimator","%breezy_id%":"fc64a49c836c","%breezy_friendly_id%":"fc64a49c836c-chief-estimator","%breezy_created_date%":"2024-07-10T14:00:19.661Z","%breezy_updated_date%":"2025-11-03T20:47:25.082Z","%_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":2861,"infowindow_disable":false},{"source":"post","title":"Maintenance Technician","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Maintenance Technician\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Maintenance Technician &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; Reports to: Foreman \u2013 Turner Mining Group Job Description: The Maintenance Technician is a skilled mining maintenance&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/maintenance-technician-2\/\" name=\"Maintenance Technician\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Maintenance Technician &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; Reports to: Foreman \u2013 Turner Mining Group Job Description: The Maintenance Technician is a skilled mining maintenance&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\/maintenance-technician-2\/","zoom":19,"extra_fields":{"post_excerpt":"Maintenance Technician &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; Reports to: Foreman \u2013 Turner Mining Group Job Description: The Maintenance Technician is a skilled mining maintenance&hellip;","post_content":"<p><strong>Maintenance Technician<\/strong>    &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&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><strong>Reports to: <\/strong><strong>Foreman \u2013 Turner Mining Group<\/strong><\/p>\n<p><strong>Job Description:<\/strong><\/p>\n<p>The Maintenance Technician is a skilled mining maintenance position within Turner Mining Group. This position will focus on maintaining equipment. The successful candidate must live the Turner Values and be an outward example to others. This position must demonstrate a strong commitment to \u201cSafe Production\u201d through decision making, priorities, and client relations.<\/p>\n<p><strong>Objectives and Contributions:<\/strong><\/p>\n<p>The Maintenance Technician is focused on key aspects that drive communication and safe production while maintaining a high level of efficiency, proactive training metrics, and preventative maintenance awareness requirements. The Maintenance Technician demonstrates safety ownership at a personal level and holds other crew members to the same high standard.&nbsp; The Maintenance Technician also assists in other production support functions as assigned.<\/p>\n<ul><li>Work with employees to ensure a high level of accuracy and engagement on hazard identification and control<\/li><li>Engage crews and leadership to define processes that motivate working towards common goals<\/li><li>Assist with MSHA regulatory training and verify compliance to standards<\/li><li>Live the values as part of a visible daily decision-making process<\/li><li>Assist with training proficiency audits<\/li><li>Involvement in risk assessment processes at various levels of the organization<\/li><li>Holds themselves and others accountable for acting like an owner (taking care of equipment, not wasting resources, using time wisely, and being accountable for conditions and behaviors)<\/li><li>Maintains a high standard of housekeeping (machine and work areas)<\/li><\/ul>\n<p><u>Culture and Communication:<\/u><\/p>\n<ul><li>Can effectively communicate in English (multi-lingual preferred)<\/li><li>Participate with site and project leaders to identify areas of improvement<\/li><li>Work with crews to support proactive near miss reporting<\/li><li>Leads by example (walks the talk)<\/li><\/ul>\n<p><u>Systems:<\/u><\/p>\n<ul><li>Ability to perform quality pre-operation machine inspections (Based on mobile equipment physical demands analysis)<\/li><li>Accurately documents 5000-23 and training checklist requirements<\/li><li>Other regulatory &amp; internal \/ external forms as required<\/li><\/ul>\n<p><u>Travel and New Site Development: <\/u><\/p>\n<ul><li>Maintains a valid and insurable driving license<\/li><li>Available to travel on short notice to support timelines and production requirements at existing sites <strong>(Preferred)<\/strong><\/li><\/ul>\n<p><u>Time and Interactions:<\/u><\/p>\n<ul><li>The Maintenance Technician must be flexible on shift schedules (days and nights) to assist with training and production needs<\/li><li>The Maintenance Technician will be self-starting, motivated, with a strong desire to be part of a team and to influence improvement. Communication is also critical to keep leadership and site-based personnel in the loop of successes, challenges, and any additional support that may be required<\/li><li>Excellent time management skills<\/li><\/ul>\n<p><u>Qualifications:<\/u><\/p>\n<ul><li>Willingness and ability to adhere to OSHA \/ MSHA regulatory requirements<\/li><li>1-3 years\u2019 experience in mining \/ heavy industry preferred<\/li><li>Working knowledge of safety systems and processes<\/li><li>Appropriate attention to detail required<\/li><li>Strong communication skills<\/li><li>Strong morals and values<\/li><li>Exemplary attendance record<\/li><li>Exemplary safety and disciplinary record<\/li><li>Willingness to be flexible on daily job duty requirements<\/li><li>Maintains a positive outspoken learning attitude<\/li><li>The Maintenance Technician must be able to safely perform each of the following tasks:<ul><li><strong>Maintenance service truck<\/strong><\/li><li><strong>G.E.T replacement<\/strong><\/li><li><strong>Replacing equipment attachments<\/strong><\/li><li><strong>Minor equipment repairs<\/strong><\/li><li><strong>Preventative maintenance backlog repairs<\/strong><\/li><li><strong>Fuel \/ lube Truck<\/strong><\/li><li><strong>Fueling \/ lubing equipment<\/strong><\/li><li><strong>Equipment fluid level monitoring<\/strong><\/li><li><strong>Marshalling equipment<\/strong><\/li><li><strong>Washing equipment<\/strong><\/li><\/ul><\/li><\/ul>\n<p><u>Other Duties:<\/u><\/p><p>In addition to the job skills above, there may be requirements for manual tasks to be completed to meet other business needs. Operators in any job duty classification may be required to participate in these additional tasks.<u><\/u><\/p>","post_title":"Maintenance Technician","post_link":"https:\/\/turnerstaffing.com\/position\/maintenance-technician-2\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Associate","%location_country%":"United States","%location_city%":"Ely","%location_state_id%":"NV","%location_state_name%":"Nevada","%location_city_state%":"Ely, NV","%education%":"Unspecified","%department%":"Equipment","%description%":"<p><strong>Maintenance Technician<\/strong>    &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&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><strong>Reports to: <\/strong><strong>Foreman \u2013 Turner Mining Group<\/strong><\/p>\n<p><strong>Job Description:<\/strong><\/p>\n<p>The Maintenance Technician is a skilled mining maintenance position within Turner Mining Group. This position will focus on maintaining equipment. The successful candidate must live the Turner Values and be an outward example to others. This position must demonstrate a strong commitment to \u201cSafe Production\u201d through decision making, priorities, and client relations.<\/p>\n<p><strong>Objectives and Contributions:<\/strong><\/p>\n<p>The Maintenance Technician is focused on key aspects that drive communication and safe production while maintaining a high level of efficiency, proactive training metrics, and preventative maintenance awareness requirements. The Maintenance Technician demonstrates safety ownership at a personal level and holds other crew members to the same high standard.&nbsp; The Maintenance Technician also assists in other production support functions as assigned.<\/p>\n<ul><li>Work with employees to ensure a high level of accuracy and engagement on hazard identification and control<\/li><li>Engage crews and leadership to define processes that motivate working towards common goals<\/li><li>Assist with MSHA regulatory training and verify compliance to standards<\/li><li>Live the values as part of a visible daily decision-making process<\/li><li>Assist with training proficiency audits<\/li><li>Involvement in risk assessment processes at various levels of the organization<\/li><li>Holds themselves and others accountable for acting like an owner (taking care of equipment, not wasting resources, using time wisely, and being accountable for conditions and behaviors)<\/li><li>Maintains a high standard of housekeeping (machine and work areas)<\/li><\/ul>\n<p><u>Culture and Communication:<\/u><\/p>\n<ul><li>Can effectively communicate in English (multi-lingual preferred)<\/li><li>Participate with site and project leaders to identify areas of improvement<\/li><li>Work with crews to support proactive near miss reporting<\/li><li>Leads by example (walks the talk)<\/li><\/ul>\n<p><u>Systems:<\/u><\/p>\n<ul><li>Ability to perform quality pre-operation machine inspections (Based on mobile equipment physical demands analysis)<\/li><li>Accurately documents 5000-23 and training checklist requirements<\/li><li>Other regulatory &amp; internal \/ external forms as required<\/li><\/ul>\n<p><u>Travel and New Site Development: <\/u><\/p>\n<ul><li>Maintains a valid and insurable driving license<\/li><li>Available to travel on short notice to support timelines and production requirements at existing sites <strong>(Preferred)<\/strong><\/li><\/ul>\n<p><u>Time and Interactions:<\/u><\/p>\n<ul><li>The Maintenance Technician must be flexible on shift schedules (days and nights) to assist with training and production needs<\/li><li>The Maintenance Technician will be self-starting, motivated, with a strong desire to be part of a team and to influence improvement. Communication is also critical to keep leadership and site-based personnel in the loop of successes, challenges, and any additional support that may be required<\/li><li>Excellent time management skills<\/li><\/ul>\n<p><u>Qualifications:<\/u><\/p>\n<ul><li>Willingness and ability to adhere to OSHA \/ MSHA regulatory requirements<\/li><li>1-3 years\u2019 experience in mining \/ heavy industry preferred<\/li><li>Working knowledge of safety systems and processes<\/li><li>Appropriate attention to detail required<\/li><li>Strong communication skills<\/li><li>Strong morals and values<\/li><li>Exemplary attendance record<\/li><li>Exemplary safety and disciplinary record<\/li><li>Willingness to be flexible on daily job duty requirements<\/li><li>Maintains a positive outspoken learning attitude<\/li><li>The Maintenance Technician must be able to safely perform each of the following tasks:<ul><li><strong>Maintenance service truck<\/strong><\/li><li><strong>G.E.T replacement<\/strong><\/li><li><strong>Replacing equipment attachments<\/strong><\/li><li><strong>Minor equipment repairs<\/strong><\/li><li><strong>Preventative maintenance backlog repairs<\/strong><\/li><li><strong>Fuel \/ lube Truck<\/strong><\/li><li><strong>Fueling \/ lubing equipment<\/strong><\/li><li><strong>Equipment fluid level monitoring<\/strong><\/li><li><strong>Marshalling equipment<\/strong><\/li><li><strong>Washing equipment<\/strong><\/li><\/ul><\/li><\/ul>\n<p><u>Other Duties:<\/u><\/p><p>In addition to the job skills above, there may be requirements for manual tasks to be completed to meet other business needs. Operators in any job duty classification may be required to participate in these additional tasks.<u><\/u><\/p>","%category%":"Operations","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/34bdbc86c3b9-maintenance-technician","%breezy_id%":"34bdbc86c3b9","%breezy_friendly_id%":"34bdbc86c3b9-maintenance-technician","%breezy_created_date%":"2025-10-28T14:12:23.178Z","%breezy_updated_date%":"2026-01-26T21:08:58.603Z","%_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":2842,"infowindow_disable":false},{"source":"post","title":"Senior Equipment Operator","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Senior Equipment Operator\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Senior Equipment Operator &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; Reports to: Foreman \u2013 Turner Mining Group Job Description: The Senior Equipment Operator is the most&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/senior-equipment-operator-2\/\" name=\"Senior Equipment Operator\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Senior Equipment Operator &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; Reports to: Foreman \u2013 Turner Mining Group Job Description: The Senior Equipment Operator is the most&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\/senior-equipment-operator-2\/","zoom":19,"extra_fields":{"post_excerpt":"Senior Equipment Operator &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; Reports to: Foreman \u2013 Turner Mining Group Job Description: The Senior Equipment Operator is the most&hellip;","post_content":"<p><strong>Senior Equipment Operator<\/strong>    &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&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><strong>Reports to: <\/strong><strong>Foreman \u2013 Turner Mining Group<\/strong><\/p>\n<p><strong>Job Description:<\/strong><\/p>\n<p>The Senior Equipment Operator is the most skilled mining operator position within Turner Mining Group. This role will oversee operational quality and efficiency as a strong field leader. The successful candidate must live the Turner Values and be an outward example to others. This position must demonstrate a strong commitment to \u201cSafe Production\u201d through decision making, priorities, and client relations.<\/p>\n<p><strong>Objectives and Contributions:<\/strong><\/p>\n<p>The Senior Equipment Operator is focused on key aspects that drive communication and safe production while maintaining a high level of efficiency, proactive training metrics, and preventative maintenance awareness requirements. The Senior Operator demonstrates safety ownership at a personal level and holds other crew members to the same high standard.&nbsp; The Senior Equipment Operator will train and develop into the Lead Equipment Operator job scope while the Lead Equipment operator is filling in for supervisory duties. <\/p>\n<ul><li>Operates mobile equipment as assigned every day based on production needs<\/li><li>Work with employees to ensure a high level of accuracy and engagement on hazard identification and control<\/li><li>Engage crews and leadership to define processes that motivate working towards common goals<\/li><li>Assist with MSHA regulatory training and verify compliance to standards<\/li><li>Live the values as part of a visible daily decision-making process<\/li><li>Assist with training efforts to grow other operators<\/li><li>Assist with training proficiency audits<\/li><li>Assist with client specific safety needs as required<\/li><li>Support risk assessment processes at various levels of the organization<\/li><li>Holds themselves and others accountable for acting like an owner (taking care of equipment, not wasting resources, using time wisely, and being accountable for conditions and behaviors)<\/li><li>Maintains a high standard of housekeeping (machine and work areas)<\/li><\/ul>\n<p><u>Culture and Communication:<\/u><\/p>\n<ul><li>Can effectively communicate in English (multi-lingual preferred)<\/li><li>Assist with daily lineout meetings and monthly safety topic communications<\/li><li>Assist with site communication programs and processes to ensure timely, specific, and value-added information<\/li><li>Assist with site and project leaders to identify areas of improvement<\/li><li>Work with crews to support proactive near miss reporting<\/li><li>Leads by example (walks the talk)<\/li><\/ul>\n<p><u>Systems:<\/u><\/p>\n<ul><li>Ability to perform quality pre-operation machine inspections (Based on mobile equipment physical demands analysis)<\/li><li>Able to perform quality workplace examination (per MSHA requirements)<\/li><li>Ability to use electronic filing and reporting systems<\/li><li>Accurately documents 5000-23 and training checklist requirements<\/li><li>Other regulatory &amp; internal \/ external forms as required<\/li><\/ul>\n<p><u>Travel and New Site Development:<\/u><\/p>\n<ul><li>Maintains a valid and insurable driving license<\/li><li>Available to travel on short notice to support timelines and production requirements at existing sites <strong>(Preferred)<\/strong><\/li><\/ul>\n<p><u>Supervisory \/ Leadership Duties<\/u><\/p>\n<ul><li>Learn and assist with key performance indicators, company targets, and daily progress reporting<\/li><li>Assist in employee timekeeping and production reports<\/li><li>Maintains compliance to Turner Mining Group Policies and Procedures including Fit for Duty requirements<\/li><li>Upholds Code of Conduct requirements<\/li><li>Spend time with maintenance, and site supervision to build relationships and develop trust<\/li><li>Assist with development \/ implement processes to reduce and eliminate repeat incidents<\/li><\/ul>\n<p><u>Time and Interactions:<\/u><\/p>\n<ul><li>The Senior Equipment Operator must be flexible on shift schedules (days and nights) to assist with training and production needs<\/li><li>The Senior Equipment Operator will be self-starting, motivated, with a strong desire to be part of a team and to influence improvement. Communication is also critical to keep leadership and site-based personnel in the loop of successes, challenges, and any additional support that may be required<\/li><li>Interacts with client supervision to discuss production challenges, targets, and collaboration between teams<\/li><li>Excellent time management skills<\/li><\/ul>\n<p><u>Qualifications:<\/u><\/p>\n<ul><li>Smart phone navigation<\/li><li>Willingness and ability to adhere to OSHA \/ MSHA regulatory requirements<\/li><li>3-5 years\u2019 experience in mining \/ heavy industry preferred<\/li><li>Working knowledge of safety systems and processes<\/li><li>Appropriate attention to detail required<\/li><li>Strong communication skills<\/li><li>Strong morals and values<\/li><li>Exemplary attendance record<\/li><li>Exemplary safety and disciplinary record<\/li><li>Willingness to be flexible on daily job duty requirements<\/li><li>Maintains a positive outspoken learning attitude<\/li><li>The Senior Equipment Operator must pass and maintain Turner Mining Group mobile equipment skills qualifications on each piece of the following equipment: <ul><li><strong>Production excavator,<\/strong><\/li><li><strong>Production loader, <\/strong><\/li><li><strong>Support excavator,<\/strong><\/li><li><strong>Dozer<\/strong><\/li><li><strong>Support loader, <\/strong><\/li><li><strong>Grader<\/strong><\/li><li><strong>Water truck, <\/strong><\/li><li><strong>Haulage truck<\/strong><\/li><\/ul><\/li><\/ul>\n<p>&nbsp;&nbsp;&nbsp;&nbsp; <u>Other Duties:<\/u><\/p><ul><li>In addition to the job skills above, there may be requirements for manual tasks to be completed to meet other business needs. Operators in any job duty classification may be required to participate in these additional tasks.<\/li><\/ul><p><u><br><\/u><\/p>","post_title":"Senior Equipment Operator","post_link":"https:\/\/turnerstaffing.com\/position\/senior-equipment-operator-2\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Senior","%location_country%":"United States","%location_city%":"Ely","%location_state_id%":"NV","%location_state_name%":"Nevada","%location_city_state%":"Ely, NV","%education%":"Unspecified","%department%":"Operations","%description%":"<p><strong>Senior Equipment Operator<\/strong>    &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&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><strong>Reports to: <\/strong><strong>Foreman \u2013 Turner Mining Group<\/strong><\/p>\n<p><strong>Job Description:<\/strong><\/p>\n<p>The Senior Equipment Operator is the most skilled mining operator position within Turner Mining Group. This role will oversee operational quality and efficiency as a strong field leader. The successful candidate must live the Turner Values and be an outward example to others. This position must demonstrate a strong commitment to \u201cSafe Production\u201d through decision making, priorities, and client relations.<\/p>\n<p><strong>Objectives and Contributions:<\/strong><\/p>\n<p>The Senior Equipment Operator is focused on key aspects that drive communication and safe production while maintaining a high level of efficiency, proactive training metrics, and preventative maintenance awareness requirements. The Senior Operator demonstrates safety ownership at a personal level and holds other crew members to the same high standard.&nbsp; The Senior Equipment Operator will train and develop into the Lead Equipment Operator job scope while the Lead Equipment operator is filling in for supervisory duties. <\/p>\n<ul><li>Operates mobile equipment as assigned every day based on production needs<\/li><li>Work with employees to ensure a high level of accuracy and engagement on hazard identification and control<\/li><li>Engage crews and leadership to define processes that motivate working towards common goals<\/li><li>Assist with MSHA regulatory training and verify compliance to standards<\/li><li>Live the values as part of a visible daily decision-making process<\/li><li>Assist with training efforts to grow other operators<\/li><li>Assist with training proficiency audits<\/li><li>Assist with client specific safety needs as required<\/li><li>Support risk assessment processes at various levels of the organization<\/li><li>Holds themselves and others accountable for acting like an owner (taking care of equipment, not wasting resources, using time wisely, and being accountable for conditions and behaviors)<\/li><li>Maintains a high standard of housekeeping (machine and work areas)<\/li><\/ul>\n<p><u>Culture and Communication:<\/u><\/p>\n<ul><li>Can effectively communicate in English (multi-lingual preferred)<\/li><li>Assist with daily lineout meetings and monthly safety topic communications<\/li><li>Assist with site communication programs and processes to ensure timely, specific, and value-added information<\/li><li>Assist with site and project leaders to identify areas of improvement<\/li><li>Work with crews to support proactive near miss reporting<\/li><li>Leads by example (walks the talk)<\/li><\/ul>\n<p><u>Systems:<\/u><\/p>\n<ul><li>Ability to perform quality pre-operation machine inspections (Based on mobile equipment physical demands analysis)<\/li><li>Able to perform quality workplace examination (per MSHA requirements)<\/li><li>Ability to use electronic filing and reporting systems<\/li><li>Accurately documents 5000-23 and training checklist requirements<\/li><li>Other regulatory &amp; internal \/ external forms as required<\/li><\/ul>\n<p><u>Travel and New Site Development:<\/u><\/p>\n<ul><li>Maintains a valid and insurable driving license<\/li><li>Available to travel on short notice to support timelines and production requirements at existing sites <strong>(Preferred)<\/strong><\/li><\/ul>\n<p><u>Supervisory \/ Leadership Duties<\/u><\/p>\n<ul><li>Learn and assist with key performance indicators, company targets, and daily progress reporting<\/li><li>Assist in employee timekeeping and production reports<\/li><li>Maintains compliance to Turner Mining Group Policies and Procedures including Fit for Duty requirements<\/li><li>Upholds Code of Conduct requirements<\/li><li>Spend time with maintenance, and site supervision to build relationships and develop trust<\/li><li>Assist with development \/ implement processes to reduce and eliminate repeat incidents<\/li><\/ul>\n<p><u>Time and Interactions:<\/u><\/p>\n<ul><li>The Senior Equipment Operator must be flexible on shift schedules (days and nights) to assist with training and production needs<\/li><li>The Senior Equipment Operator will be self-starting, motivated, with a strong desire to be part of a team and to influence improvement. Communication is also critical to keep leadership and site-based personnel in the loop of successes, challenges, and any additional support that may be required<\/li><li>Interacts with client supervision to discuss production challenges, targets, and collaboration between teams<\/li><li>Excellent time management skills<\/li><\/ul>\n<p><u>Qualifications:<\/u><\/p>\n<ul><li>Smart phone navigation<\/li><li>Willingness and ability to adhere to OSHA \/ MSHA regulatory requirements<\/li><li>3-5 years\u2019 experience in mining \/ heavy industry preferred<\/li><li>Working knowledge of safety systems and processes<\/li><li>Appropriate attention to detail required<\/li><li>Strong communication skills<\/li><li>Strong morals and values<\/li><li>Exemplary attendance record<\/li><li>Exemplary safety and disciplinary record<\/li><li>Willingness to be flexible on daily job duty requirements<\/li><li>Maintains a positive outspoken learning attitude<\/li><li>The Senior Equipment Operator must pass and maintain Turner Mining Group mobile equipment skills qualifications on each piece of the following equipment: <ul><li><strong>Production excavator,<\/strong><\/li><li><strong>Production loader, <\/strong><\/li><li><strong>Support excavator,<\/strong><\/li><li><strong>Dozer<\/strong><\/li><li><strong>Support loader, <\/strong><\/li><li><strong>Grader<\/strong><\/li><li><strong>Water truck, <\/strong><\/li><li><strong>Haulage truck<\/strong><\/li><\/ul><\/li><\/ul>\n<p>&nbsp;&nbsp;&nbsp;&nbsp; <u>Other Duties:<\/u><\/p><ul><li>In addition to the job skills above, there may be requirements for manual tasks to be completed to meet other business needs. Operators in any job duty classification may be required to participate in these additional tasks.<\/li><\/ul><p><u><br><\/u><\/p>","%category%":"Operations","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/e1853786a6e0-senior-equipment-operator","%breezy_id%":"e1853786a6e0","%breezy_friendly_id%":"e1853786a6e0-senior-equipment-operator","%breezy_created_date%":"2025-10-28T14:19:03.694Z","%breezy_updated_date%":"2026-01-26T19:35:41.668Z","%_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":2843,"infowindow_disable":false},{"source":"post","title":"Heavy Equipment Fuel and Lube Technician","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Heavy Equipment Fuel and Lube Technician\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Fuel \/ Lube Technician &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; Reports to: Foreman \u2013 Turner Mining Group Job Description: The Fuel \/ Lube Technician is&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/fuel-lube-technician-2\/\" name=\"Heavy Equipment Fuel and Lube Technician\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Fuel \/ Lube Technician &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; Reports to: Foreman \u2013 Turner Mining Group Job Description: The Fuel \/ Lube Technician is&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\/fuel-lube-technician-2\/","zoom":19,"extra_fields":{"post_excerpt":"Fuel \/ Lube Technician &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; Reports to: Foreman \u2013 Turner Mining Group Job Description: The Fuel \/ Lube Technician is&hellip;","post_content":"<p><strong>Fuel \/ Lube Technician<\/strong>    &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&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><strong>Reports to: <\/strong><strong>Foreman \u2013 Turner Mining Group<\/strong><\/p>\n<p><strong>Job Description:<\/strong><\/p>\n<p>The Fuel \/ Lube Technician is a developing Maintenance Technician role within Turner Mining Group. This role will be focused on maintaining equipment. The successful candidate must live the Turner Values and be an outward example to others. This position must demonstrate a strong commitment to \u201cSafe Production\u201d through decision making, priorities, and client relations.<\/p>\n<p><strong>Objectives and Contributions:<\/strong><\/p>\n<p>The Fuel \/ Lube Technician is focused on key aspects that drive communication and safe production while maintaining a high level of efficiency, proactive training metrics, and preventative maintenance awareness requirements. The Fuel \/ Lube Technician demonstrates safety ownership at a personal level and holds other crew members to the same high standard.&nbsp; The Fuel \/ Lube Technician also assists in other production support functions as assigned.<\/p>\n<ul><li>Work with employees to ensure a high level of accuracy and engagement on hazard identification and control<\/li><li>Engage crews and leadership to define processes that motivate working towards common goals<\/li><li>Assist with MSHA regulatory training and verify compliance to standards<\/li><li>Live the values as part of a visible daily decision-making process<\/li><li>Assist with training proficiency audits<\/li><li>Involvement in risk assessment processes at various levels of the organization<\/li><li>Holds themselves and others accountable for acting like an owner (taking care of equipment, not wasting resources, using time wisely, and being accountable for conditions and behaviors)<\/li><li>Maintains a high standard of housekeeping (machine and work areas)<\/li><\/ul>\n<p><u>Culture and Communication:<\/u><\/p>\n<ul><li>Can effectively communicate in English (multi-lingual preferred)<\/li><li>Participate with site and project leaders to identify areas of improvement<\/li><li>Work with crews to support proactive near miss reporting<\/li><li>Leads by example (walks the talk)<\/li><\/ul>\n<p><u>Systems:<\/u><\/p>\n<ul><li>Ability to perform quality pre-operation machine inspections (Based on mobile equipment physical demands analysis)<\/li><li>Accurately documents 5000-23 and training checklist requirements<\/li><li>Other regulatory &amp; internal \/ external forms as required<\/li><li>Maintains a valid and insurable driving license<\/li><\/ul>\n<p><u>Travel and New Site Development: <\/u><\/p>\n<p><u>Time and Interactions:<\/u><\/p>\n<ul><li>The Fuel \/ Lube Technician must be flexible on shift schedules (days and nights) to assist with training and production needs<\/li><li>The Fuel \/ Lube Technician will be self-starting, motivated, with a strong desire to be part of a team and to influence improvement. Communication is also critical to keep leadership and site-based personnel in the loop of successes, challenges, and any additional support that may be required<\/li><li>Excellent time management skills<\/li><\/ul>\n<p><u>Qualifications:<\/u><\/p>\n<ul><li>Willingness and ability to adhere to OSHA \/ MSHA regulatory requirements<\/li><li>0-2 years\u2019 experience in mining \/ heavy industry preferred<\/li><li>Working knowledge of safety systems and processes<\/li><li>Appropriate attention to detail required<\/li><li>Strong communication skills<\/li><li>Strong morals and values<\/li><li>Exemplary attendance record<\/li><li>Exemplary safety and disciplinary record<\/li><li>Willingness to be flexible on daily job duty requirements<\/li><li>Maintains a positive outspoken learning attitude<\/li><li>The Fuel \/ Lube Technician must be able to safely perform each of the following tasks: <ul><li><strong>Fuel \/ lube Truck<\/strong><\/li><li><strong>Fueling \/ lubing equipment<\/strong><\/li><li><strong>Equipment fluid level monitoring<\/strong><\/li><li><strong>Marshalling equipment<\/strong><\/li><li><strong>Washing equipment<\/strong><\/li><\/ul><\/li><\/ul><p><strong><u>Other Duties:<\/u><br><\/strong><\/p><p><strong><\/strong>In addition to the job skills above, there may be requirements for manual tasks to be completed to meet other business needs. Operators in any job duty classification may be required to participate in these additional tasks.<br><\/p>","post_title":"Heavy Equipment Fuel and Lube Technician","post_link":"https:\/\/turnerstaffing.com\/position\/fuel-lube-technician-2\/","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%":"Unspecified","%department%":"Equipment Maintenance","%description%":"<p><strong>Fuel \/ Lube Technician<\/strong>    &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&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><strong>Reports to: <\/strong><strong>Foreman \u2013 Turner Mining Group<\/strong><\/p>\n<p><strong>Job Description:<\/strong><\/p>\n<p>The Fuel \/ Lube Technician is a developing Maintenance Technician role within Turner Mining Group. This role will be focused on maintaining equipment. The successful candidate must live the Turner Values and be an outward example to others. This position must demonstrate a strong commitment to \u201cSafe Production\u201d through decision making, priorities, and client relations.<\/p>\n<p><strong>Objectives and Contributions:<\/strong><\/p>\n<p>The Fuel \/ Lube Technician is focused on key aspects that drive communication and safe production while maintaining a high level of efficiency, proactive training metrics, and preventative maintenance awareness requirements. The Fuel \/ Lube Technician demonstrates safety ownership at a personal level and holds other crew members to the same high standard.&nbsp; The Fuel \/ Lube Technician also assists in other production support functions as assigned.<\/p>\n<ul><li>Work with employees to ensure a high level of accuracy and engagement on hazard identification and control<\/li><li>Engage crews and leadership to define processes that motivate working towards common goals<\/li><li>Assist with MSHA regulatory training and verify compliance to standards<\/li><li>Live the values as part of a visible daily decision-making process<\/li><li>Assist with training proficiency audits<\/li><li>Involvement in risk assessment processes at various levels of the organization<\/li><li>Holds themselves and others accountable for acting like an owner (taking care of equipment, not wasting resources, using time wisely, and being accountable for conditions and behaviors)<\/li><li>Maintains a high standard of housekeeping (machine and work areas)<\/li><\/ul>\n<p><u>Culture and Communication:<\/u><\/p>\n<ul><li>Can effectively communicate in English (multi-lingual preferred)<\/li><li>Participate with site and project leaders to identify areas of improvement<\/li><li>Work with crews to support proactive near miss reporting<\/li><li>Leads by example (walks the talk)<\/li><\/ul>\n<p><u>Systems:<\/u><\/p>\n<ul><li>Ability to perform quality pre-operation machine inspections (Based on mobile equipment physical demands analysis)<\/li><li>Accurately documents 5000-23 and training checklist requirements<\/li><li>Other regulatory &amp; internal \/ external forms as required<\/li><li>Maintains a valid and insurable driving license<\/li><\/ul>\n<p><u>Travel and New Site Development: <\/u><\/p>\n<p><u>Time and Interactions:<\/u><\/p>\n<ul><li>The Fuel \/ Lube Technician must be flexible on shift schedules (days and nights) to assist with training and production needs<\/li><li>The Fuel \/ Lube Technician will be self-starting, motivated, with a strong desire to be part of a team and to influence improvement. Communication is also critical to keep leadership and site-based personnel in the loop of successes, challenges, and any additional support that may be required<\/li><li>Excellent time management skills<\/li><\/ul>\n<p><u>Qualifications:<\/u><\/p>\n<ul><li>Willingness and ability to adhere to OSHA \/ MSHA regulatory requirements<\/li><li>0-2 years\u2019 experience in mining \/ heavy industry preferred<\/li><li>Working knowledge of safety systems and processes<\/li><li>Appropriate attention to detail required<\/li><li>Strong communication skills<\/li><li>Strong morals and values<\/li><li>Exemplary attendance record<\/li><li>Exemplary safety and disciplinary record<\/li><li>Willingness to be flexible on daily job duty requirements<\/li><li>Maintains a positive outspoken learning attitude<\/li><li>The Fuel \/ Lube Technician must be able to safely perform each of the following tasks: <ul><li><strong>Fuel \/ lube Truck<\/strong><\/li><li><strong>Fueling \/ lubing equipment<\/strong><\/li><li><strong>Equipment fluid level monitoring<\/strong><\/li><li><strong>Marshalling equipment<\/strong><\/li><li><strong>Washing equipment<\/strong><\/li><\/ul><\/li><\/ul><p><strong><u>Other Duties:<\/u><br><\/strong><\/p><p><strong><\/strong>In addition to the job skills above, there may be requirements for manual tasks to be completed to meet other business needs. Operators in any job duty classification may be required to participate in these additional tasks.<br><\/p>","%category%":"Operations","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/1c7c3acd72e7-heavy-equipment-fuel-and-lube-technician","%breezy_id%":"1c7c3acd72e7","%breezy_friendly_id%":"1c7c3acd72e7-heavy-equipment-fuel-and-lube-technician","%breezy_created_date%":"2025-10-28T13:46:26.102Z","%breezy_updated_date%":"2026-01-27T15:07:43.432Z","%_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":2840,"infowindow_disable":false},{"source":"post","title":"General Laborer","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    General Laborer\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Position Overview We are seeking a dependable and hardworking General Laborer to join our team in Wyalusing, PA. This position&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/general-laborer-2\/\" name=\"General Laborer\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Position Overview We are seeking a dependable and hardworking General Laborer to join our team in Wyalusing, PA. This position&hellip;","address":"Wyalusing, PA, USA","location":{"lat":"41.6681309","city":"Wyalusing","state":"PA","country":"United States","lng":"-76.2618786","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/general-laborer-2\/","zoom":19,"extra_fields":{"post_excerpt":"Position Overview We are seeking a dependable and hardworking General Laborer to join our team in Wyalusing, PA. This position&hellip;","post_content":"<h3><strong>Position Overview<\/strong><\/h3>\n<p>We are seeking a dependable and hardworking <strong>General Laborer<\/strong> to join our team in Wyalusing, PA. This position supports electrical installation projects within the oil and gas industry and involves hands-on work assisting with running tubing along conduit, insulating pipe, and performing general labor tasks as directed by project supervisors.<\/p>\n<h3><strong>Key Responsibilities<\/strong><\/h3>\n<ul>\n<li>\n<p>Assist in running and securing tubing along conduit systems.<\/p>\n<\/li>\n<li>\n<p>Install and apply pipe insulation materials according to project specifications.<\/p>\n<\/li>\n<li>\n<p>Support electricians and technicians in field operations and installation work.<\/p>\n<\/li>\n<li>\n<p>Maintain a clean, safe, and organized work area.<\/p>\n<\/li>\n<li>\n<p>Load, unload, and move materials, tools, and equipment on job sites.<\/p>\n<\/li>\n<li>\n<p>Follow all company safety procedures and regulatory guidelines.<\/p>\n<\/li>\n<li>\n<p>Perform other general labor duties as assigned by the site supervisor or foreman.<\/p>\n<\/li>\n<\/ul>\n<h3><strong>Qualifications<\/strong><\/h3>\n<ul>\n<li>\n<p>Previous experience in construction, oil &amp; gas, or industrial environments preferred but not required.<\/p>\n<\/li>\n<li>\n<p>Ability to use hand and power tools safely and effectively.<\/p>\n<\/li>\n<li>\n<p>Physically able to lift up to 50 lbs, stand for long periods, and work in various outdoor conditions.<\/p>\n<\/li>\n<li>\n<p>Strong attention to detail and commitment to safety.<\/p>\n<\/li>\n<li>\n<p>Reliable transportation to and from the job site.<\/p>\n<\/li>\n<li>\n<p>Willingness to learn and follow directions closely.<\/p><\/li><\/ul>","post_title":"General Laborer","post_link":"https:\/\/turnerstaffing.com\/position\/general-laborer-2\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Entry Level","%location_country%":"United States","%location_city%":"Wyalusing","%location_state_id%":"PA","%location_state_name%":"Pennsylvania","%location_city_state%":"Wyalusing, PA","%education%":"Unspecified","%department%":"","%description%":"<h3><strong>Position Overview<\/strong><\/h3>\n<p>We are seeking a dependable and hardworking <strong>General Laborer<\/strong> to join our team in Wyalusing, PA. This position supports electrical installation projects within the oil and gas industry and involves hands-on work assisting with running tubing along conduit, insulating pipe, and performing general labor tasks as directed by project supervisors.<\/p>\n<h3><strong>Key Responsibilities<\/strong><\/h3>\n<ul>\n<li>\n<p>Assist in running and securing tubing along conduit systems.<\/p>\n<\/li>\n<li>\n<p>Install and apply pipe insulation materials according to project specifications.<\/p>\n<\/li>\n<li>\n<p>Support electricians and technicians in field operations and installation work.<\/p>\n<\/li>\n<li>\n<p>Maintain a clean, safe, and organized work area.<\/p>\n<\/li>\n<li>\n<p>Load, unload, and move materials, tools, and equipment on job sites.<\/p>\n<\/li>\n<li>\n<p>Follow all company safety procedures and regulatory guidelines.<\/p>\n<\/li>\n<li>\n<p>Perform other general labor duties as assigned by the site supervisor or foreman.<\/p>\n<\/li>\n<\/ul>\n<h3><strong>Qualifications<\/strong><\/h3>\n<ul>\n<li>\n<p>Previous experience in construction, oil &amp; gas, or industrial environments preferred but not required.<\/p>\n<\/li>\n<li>\n<p>Ability to use hand and power tools safely and effectively.<\/p>\n<\/li>\n<li>\n<p>Physically able to lift up to 50 lbs, stand for long periods, and work in various outdoor conditions.<\/p>\n<\/li>\n<li>\n<p>Strong attention to detail and commitment to safety.<\/p>\n<\/li>\n<li>\n<p>Reliable transportation to and from the job site.<\/p>\n<\/li>\n<li>\n<p>Willingness to learn and follow directions closely.<\/p><\/li><\/ul>","%category%":"Operations","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/5f3b1b456b3b-general-laborer","%breezy_id%":"5f3b1b456b3b","%breezy_friendly_id%":"5f3b1b456b3b-general-laborer","%breezy_created_date%":"2025-10-27T17:26:15.554Z","%breezy_updated_date%":"2025-12-03T19:44:02.687Z","%_wpgmp_location_city%":"Wyalusing","%_wpgmp_location_state%":"PA","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Wyalusing, PA, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"41.6681309","%_wpgmp_metabox_longitude%":"-76.2618786","%rank_math_internal_links_processed%":"1"}},"id":2837,"infowindow_disable":false},{"source":"post","title":"Director of Maintenance","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Director of Maintenance\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Director of Maintenance Role Summary The Director of Maintenance is responsible for designing, implementing, and governing Turner Mining Group\u2019s maintenance&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/director-of-maintenance\/\" name=\"Director of Maintenance\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Director of Maintenance Role Summary The Director of Maintenance is responsible for designing, implementing, and governing Turner Mining Group\u2019s maintenance&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\/director-of-maintenance\/","zoom":19,"extra_fields":{"post_excerpt":"Director of Maintenance Role Summary The Director of Maintenance is responsible for designing, implementing, and governing Turner Mining Group\u2019s maintenance&hellip;","post_content":"<p>Director of Maintenance<\/p>\n<p><strong>Role Summary<\/strong><\/p>\n<p>The Director of Maintenance is responsible for designing, implementing, and governing Turner Mining Group\u2019s maintenance program across all projects and fleet. This role focuses on building scalable systems, setting standards, and driving reliability and cost performance through strong maintenance governance and leadership. The Director does not manage daily maintenance execution but ensures that Maintenance Managers and Superintendents are equipped, trained, and held accountable to operate effectively within Turner\u2019s maintenance framework.<\/p>\n<p><strong>Key Responsibilities<\/strong><\/p>\n<p>Maintenance Program Standards &amp; Systems<\/p>\n<p>-\tDevelop and maintain companywide maintenance standards covering documentation, coding, PM strategy, inspections, oil sampling, condition monitoring, and work order management<\/p>\n<p>-\tDefine critical maintenance workflows including breakdown response, planned work, major repairs, and warranty claims<\/p>\n<p>-\tEnsure maintenance systems are practical, consistently applied, and scalable across projects<\/p>\n<p>Work Management, Planning &amp; System Performance<\/p>\n<p>-\tEstablish standards for work order planning, scheduling, prioritization, and closeout<\/p>\n<p>-\tDefine and govern machine status tracking, downtime definitions, and failure coding<\/p>\n<p>-\tEnsure maintenance data supports reliability analysis (availability, MTBF, MTTR, cost per hour) and financial reporting<\/p>\n<p>-\tAlign maintenance system usage with accounting and cost controls<\/p>\n<p>Project Maintenance Planning &amp; Capability Development<\/p>\n<p>-\tDefine the structure and content of project-specific maintenance plans<\/p>\n<p>-\tEnsure warranty requirements, lessons learned, common failure modes, vendor relationships, and wear expectations are captured and deployed<\/p>\n<p>-\tEstablish training and onboarding expectations for Maintenance Managers and Superintendents<\/p>\n<p>-\tDefine KPI expectations, reporting cadence, and performance review processes<\/p>\n<p>Maintenance Cost Forecasting &amp; Governance<\/p>\n<p>-\tOwn maintenance forecasting standards, including rolling short-term forecasts tied to production plans<\/p>\n<p>-\tApprove major maintenance spend and repair-versus-replace decisions<\/p>\n<p>-\tMonitor forecasted versus actual maintenance costs and identify key cost drivers<\/p>\n<p>-\tEnsure warranty recovery and vendor accountability are consistently pursued<\/p>\n<p>Leadership &amp; Reliability Improvement<\/p>\n<p>-\tLead reliability improvement efforts across the fleet and projects<\/p>\n<p>-\tDrive root cause analysis for significant or repeat failures<\/p>\n<p>-\tCoach and develop Maintenance Managers as leaders and system owners<\/p>\n<p>-\tPartner with Operations to improve operating discipline that affects asset life and availability<\/p>\n<p>-\tContinuously improve Turner\u2019s maintenance program as fleet, projects, and scale evolve<\/p>\n<p><strong>Reporting Structure<\/strong><\/p>\n<p>-\tReports to: Executive Leadership (Chief Business Officer)<\/p>\n<p>-\tDirect reports: Maintenance Managers<\/p>\n<p>-\tIndirect reports: Maintenance Superintendents and site maintenance teams<\/p>\n<p>Success Measures (High-Level)<\/p>\n<p>-\tConsistent maintenance execution across projects<\/p>\n<p>-\tImproved asset availability and reduced unplanned downtime<\/p>\n<p>-\tHigh-quality maintenance data supporting reliability and cost decisions<\/p>\n<p>-\tPredictable and controlled maintenance spend<\/p>\n<p>-\tStrong Maintenance Manager and Superintendent capability<\/p>\n<p><strong>Team Structure Overview<\/strong><\/p>\n<p>Director of Maintenance<\/p>\n<p>Program Owner | System Architect | Governance | Second-Level Approval<\/p>\n<p>-\tOwns the design, implementation, and continuous improvement of Turner\u2019s maintenance program<\/p>\n<p>-\tEstablishes companywide standards for maintenance planning, execution, documentation, approvals, and reporting<\/p>\n<p>-\tDefines reliability, cost, and performance expectations across the fleet and all projects<\/p>\n<p>-\tSets approval frameworks and governance for maintenance spend and major repairs<\/p>\n<p>-\tProvides strategic direction, coaching, and oversight to Maintenance Managers<\/p>\n<p>-\tEnsures maintenance systems produce consistent, reliable data that supports operational and financial decision-making<\/p>\n<p>Maintenance Managers<\/p>\n<p>Execution Oversight | Tactical Planning | First-Level Approval<\/p>\n<p>-\tEnsure Turner\u2019s maintenance standards are executed consistently across assigned projects<\/p>\n<p>-\tOversee Maintenance Superintendents and hold them accountable to defined systems and expectations<\/p>\n<p>-\tServe as first-level approvers for maintenance work orders and spend<\/p>\n<p>-\tClear outstanding approvals, resolve accounting issues, and ensure timely and accurate work order closeout<\/p>\n<p>-\tLead tactical development of project-specific maintenance plans within Director-established standards<\/p>\n<p>-\tEscalate risks, chronic issues, and system gaps to the Director<\/p>\n<p>Maintenance Superintendents<\/p>\n<p>Field Execution | Asset Availability | Crew Leadership<\/p>\n<p>-\tOwn day-to-day maintenance execution at the project level<\/p>\n<p>-\tKeep equipment operating to meet production requirements within Turner\u2019s maintenance systems<\/p>\n<p>-\tPlan and execute work orders, manage technicians and vendors, and respond to breakdowns<\/p>\n<p>-\tEnsure inspections, PMs, and documentation are completed to standard<\/p>\n<p>-\tCommunicate issues, risks, and performance trends through the Maintenance Manager<\/p>\n<p>Operating Principle:<\/p>\n<p>-\tThe Director builds and governs the system<\/p>\n<p>-\tManagers ensure it is executed well<\/p>\n<p>-\tSuperintendents keep the job running within the system<\/p>","post_title":"Director of Maintenance","post_link":"https:\/\/turnerstaffing.com\/position\/director-of-maintenance\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Senior","%location_country%":"United States","%location_city%":"Bloomington","%location_state_id%":"IN","%location_state_name%":"Indiana","%location_city_state%":"Bloomington, IN","%education%":"Unspecified","%department%":"Maintenance","%description%":"<p>Director of Maintenance<\/p>\n<p><strong>Role Summary<\/strong><\/p>\n<p>The Director of Maintenance is responsible for designing, implementing, and governing Turner Mining Group\u2019s maintenance program across all projects and fleet. This role focuses on building scalable systems, setting standards, and driving reliability and cost performance through strong maintenance governance and leadership. The Director does not manage daily maintenance execution but ensures that Maintenance Managers and Superintendents are equipped, trained, and held accountable to operate effectively within Turner\u2019s maintenance framework.<\/p>\n<p><strong>Key Responsibilities<\/strong><\/p>\n<p>Maintenance Program Standards &amp; Systems<\/p>\n<p>-\tDevelop and maintain companywide maintenance standards covering documentation, coding, PM strategy, inspections, oil sampling, condition monitoring, and work order management<\/p>\n<p>-\tDefine critical maintenance workflows including breakdown response, planned work, major repairs, and warranty claims<\/p>\n<p>-\tEnsure maintenance systems are practical, consistently applied, and scalable across projects<\/p>\n<p>Work Management, Planning &amp; System Performance<\/p>\n<p>-\tEstablish standards for work order planning, scheduling, prioritization, and closeout<\/p>\n<p>-\tDefine and govern machine status tracking, downtime definitions, and failure coding<\/p>\n<p>-\tEnsure maintenance data supports reliability analysis (availability, MTBF, MTTR, cost per hour) and financial reporting<\/p>\n<p>-\tAlign maintenance system usage with accounting and cost controls<\/p>\n<p>Project Maintenance Planning &amp; Capability Development<\/p>\n<p>-\tDefine the structure and content of project-specific maintenance plans<\/p>\n<p>-\tEnsure warranty requirements, lessons learned, common failure modes, vendor relationships, and wear expectations are captured and deployed<\/p>\n<p>-\tEstablish training and onboarding expectations for Maintenance Managers and Superintendents<\/p>\n<p>-\tDefine KPI expectations, reporting cadence, and performance review processes<\/p>\n<p>Maintenance Cost Forecasting &amp; Governance<\/p>\n<p>-\tOwn maintenance forecasting standards, including rolling short-term forecasts tied to production plans<\/p>\n<p>-\tApprove major maintenance spend and repair-versus-replace decisions<\/p>\n<p>-\tMonitor forecasted versus actual maintenance costs and identify key cost drivers<\/p>\n<p>-\tEnsure warranty recovery and vendor accountability are consistently pursued<\/p>\n<p>Leadership &amp; Reliability Improvement<\/p>\n<p>-\tLead reliability improvement efforts across the fleet and projects<\/p>\n<p>-\tDrive root cause analysis for significant or repeat failures<\/p>\n<p>-\tCoach and develop Maintenance Managers as leaders and system owners<\/p>\n<p>-\tPartner with Operations to improve operating discipline that affects asset life and availability<\/p>\n<p>-\tContinuously improve Turner\u2019s maintenance program as fleet, projects, and scale evolve<\/p>\n<p><strong>Reporting Structure<\/strong><\/p>\n<p>-\tReports to: Executive Leadership (Chief Business Officer)<\/p>\n<p>-\tDirect reports: Maintenance Managers<\/p>\n<p>-\tIndirect reports: Maintenance Superintendents and site maintenance teams<\/p>\n<p>Success Measures (High-Level)<\/p>\n<p>-\tConsistent maintenance execution across projects<\/p>\n<p>-\tImproved asset availability and reduced unplanned downtime<\/p>\n<p>-\tHigh-quality maintenance data supporting reliability and cost decisions<\/p>\n<p>-\tPredictable and controlled maintenance spend<\/p>\n<p>-\tStrong Maintenance Manager and Superintendent capability<\/p>\n<p><strong>Team Structure Overview<\/strong><\/p>\n<p>Director of Maintenance<\/p>\n<p>Program Owner | System Architect | Governance | Second-Level Approval<\/p>\n<p>-\tOwns the design, implementation, and continuous improvement of Turner\u2019s maintenance program<\/p>\n<p>-\tEstablishes companywide standards for maintenance planning, execution, documentation, approvals, and reporting<\/p>\n<p>-\tDefines reliability, cost, and performance expectations across the fleet and all projects<\/p>\n<p>-\tSets approval frameworks and governance for maintenance spend and major repairs<\/p>\n<p>-\tProvides strategic direction, coaching, and oversight to Maintenance Managers<\/p>\n<p>-\tEnsures maintenance systems produce consistent, reliable data that supports operational and financial decision-making<\/p>\n<p>Maintenance Managers<\/p>\n<p>Execution Oversight | Tactical Planning | First-Level Approval<\/p>\n<p>-\tEnsure Turner\u2019s maintenance standards are executed consistently across assigned projects<\/p>\n<p>-\tOversee Maintenance Superintendents and hold them accountable to defined systems and expectations<\/p>\n<p>-\tServe as first-level approvers for maintenance work orders and spend<\/p>\n<p>-\tClear outstanding approvals, resolve accounting issues, and ensure timely and accurate work order closeout<\/p>\n<p>-\tLead tactical development of project-specific maintenance plans within Director-established standards<\/p>\n<p>-\tEscalate risks, chronic issues, and system gaps to the Director<\/p>\n<p>Maintenance Superintendents<\/p>\n<p>Field Execution | Asset Availability | Crew Leadership<\/p>\n<p>-\tOwn day-to-day maintenance execution at the project level<\/p>\n<p>-\tKeep equipment operating to meet production requirements within Turner\u2019s maintenance systems<\/p>\n<p>-\tPlan and execute work orders, manage technicians and vendors, and respond to breakdowns<\/p>\n<p>-\tEnsure inspections, PMs, and documentation are completed to standard<\/p>\n<p>-\tCommunicate issues, risks, and performance trends through the Maintenance Manager<\/p>\n<p>Operating Principle:<\/p>\n<p>-\tThe Director builds and governs the system<\/p>\n<p>-\tManagers ensure it is executed well<\/p>\n<p>-\tSuperintendents keep the job running within the system<\/p>","%category%":"Management","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/fbe030913c67-director-of-maintenance","%breezy_id%":"fbe030913c67","%breezy_friendly_id%":"fbe030913c67-director-of-maintenance","%breezy_created_date%":"2025-10-16T13:46:22.579Z","%breezy_updated_date%":"2025-12-29T18:18:39.174Z","%_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":2830,"infowindow_disable":false},{"source":"post","title":"Heavy Equipment Operator Instructor\/Trainer","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Heavy Equipment Operator Instructor\/Trainer\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    The Trainer helps new and current construction employees build the skills they need to work safely, efficiently, and grow within&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/equipment-safety-training-specialist\/\" name=\"Heavy Equipment Operator Instructor\/Trainer\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"The Trainer helps new and current construction employees build the skills they need to work safely, efficiently, and grow within&hellip;","address":"Bowmansville, PA, USA","location":{"lat":"40.1967609","city":"Bowmansville","state":"PA","country":"United States","lng":"-76.0174416","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/equipment-safety-training-specialist\/","zoom":19,"extra_fields":{"post_excerpt":"The Trainer helps new and current construction employees build the skills they need to work safely, efficiently, and grow within&hellip;","post_content":"<p>The Trainer helps new and current construction employees build the skills they need to work <\/p>\n<p>safely, efficiently, and grow within the company. This role provides hands-on and classroom <\/p>\n<p>training for supervisors, operators and laborers, supports career development, and promotes <\/p>\n<p>proper equipment use to reduce costs and improve jobsite performance.<\/p>\n<p>ESSENTIAL DUTIES AND RESPONSIBILITIES:<\/p>\n<p>Include the following. Other duties may be assigned.<\/p>\n<p>\u2022 Train new and existing employees on equipment operation, safety, and best practices.<\/p>\n<p>\u2022 Assess skills and provide customized training to improve performance.<\/p>\n<p>\u2022 Help with hiring and promotion by evaluating operator and laborer abilities.<\/p>\n<p>\u2022 Create and lead classroom, field, and online training sessions.<\/p>\n<p>\u2022 Manage the Operator Certification Program, including testing and field follow-up.<\/p>\n<p>\u2022 Work closely with field employees and supervisors to support development.<\/p>\n<p>\u2022 Promote and teach safe work practices; participate on the Safety Committee.<\/p>\n<p>\u2022 Understand company equipment, its safe and efficient use, and how to prevent damage <\/p>\n<p>or misuse.<\/p>\n<p>\u2022 Stays ahead of industry trends by using technology to enhance training and anticipate <\/p>\n<p>future needs<\/p>\n<p>\u2022 Ability to tailor communication and training methods to suit different audiences, <\/p>\n<p>ensuring information is delivered in the most effective format.<\/p>\n<p>\u2022 Builds strong relationships and develops peer leaders to extend the reach and impact of <\/p>\n<p>training throughout the organization.<\/p>\n<p>EDUCATION and\/or EXPERIENCE:<\/p>\n<p>\u2022 Experience productively and safely operating various heavy equipment in construction.<\/p>\n<p>\u2022 Strong understanding of earthmoving and construction practices.<\/p>\n<p>\u2022 Skilled in teaching and coaching employees of different experience levels.<\/p>\n<p>\u2022 Clear communicator, both in writing and in person.<\/p>\n<p>\u2022 Patient, professional, and a team player.<\/p>\n<p>\u2022 Self-motivated with strong problem-solving and people skills.<\/p>\n<p>\u2022 Able to recognize and develop employee strengths to help them succeed.<\/p>\n<p>\u2022 Strong public speaking and presentation skills, with experience delivering training to <\/p>\n<p>groups of various sizes in both classroom and field settings.<\/p>","post_title":"Heavy Equipment Operator Instructor\/Trainer","post_link":"https:\/\/turnerstaffing.com\/position\/equipment-safety-training-specialist\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"","%location_country%":"United States","%location_city%":"Bowmansville","%location_state_id%":"PA","%location_state_name%":"Pennsylvania","%location_city_state%":"Bowmansville, PA","%education%":"","%department%":"","%description%":"<p>The Trainer helps new and current construction employees build the skills they need to work <\/p>\n<p>safely, efficiently, and grow within the company. This role provides hands-on and classroom <\/p>\n<p>training for supervisors, operators and laborers, supports career development, and promotes <\/p>\n<p>proper equipment use to reduce costs and improve jobsite performance.<\/p>\n<p>ESSENTIAL DUTIES AND RESPONSIBILITIES:<\/p>\n<p>Include the following. Other duties may be assigned.<\/p>\n<p>\u2022 Train new and existing employees on equipment operation, safety, and best practices.<\/p>\n<p>\u2022 Assess skills and provide customized training to improve performance.<\/p>\n<p>\u2022 Help with hiring and promotion by evaluating operator and laborer abilities.<\/p>\n<p>\u2022 Create and lead classroom, field, and online training sessions.<\/p>\n<p>\u2022 Manage the Operator Certification Program, including testing and field follow-up.<\/p>\n<p>\u2022 Work closely with field employees and supervisors to support development.<\/p>\n<p>\u2022 Promote and teach safe work practices; participate on the Safety Committee.<\/p>\n<p>\u2022 Understand company equipment, its safe and efficient use, and how to prevent damage <\/p>\n<p>or misuse.<\/p>\n<p>\u2022 Stays ahead of industry trends by using technology to enhance training and anticipate <\/p>\n<p>future needs<\/p>\n<p>\u2022 Ability to tailor communication and training methods to suit different audiences, <\/p>\n<p>ensuring information is delivered in the most effective format.<\/p>\n<p>\u2022 Builds strong relationships and develops peer leaders to extend the reach and impact of <\/p>\n<p>training throughout the organization.<\/p>\n<p>EDUCATION and\/or EXPERIENCE:<\/p>\n<p>\u2022 Experience productively and safely operating various heavy equipment in construction.<\/p>\n<p>\u2022 Strong understanding of earthmoving and construction practices.<\/p>\n<p>\u2022 Skilled in teaching and coaching employees of different experience levels.<\/p>\n<p>\u2022 Clear communicator, both in writing and in person.<\/p>\n<p>\u2022 Patient, professional, and a team player.<\/p>\n<p>\u2022 Self-motivated with strong problem-solving and people skills.<\/p>\n<p>\u2022 Able to recognize and develop employee strengths to help them succeed.<\/p>\n<p>\u2022 Strong public speaking and presentation skills, with experience delivering training to <\/p>\n<p>groups of various sizes in both classroom and field settings.<\/p>","%category%":"Operations","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/ce7f98ceee69-heavy-equipment-operator-instructor-trainer","%breezy_id%":"ce7f98ceee69","%breezy_friendly_id%":"ce7f98ceee69-heavy-equipment-operator-instructor-trainer","%breezy_created_date%":"2025-10-14T20:45:02.280Z","%breezy_updated_date%":"2026-01-14T19:17:41.295Z","%_wpgmp_location_city%":"Bowmansville","%_wpgmp_location_state%":"PA","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Bowmansville, PA, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"40.1967609","%_wpgmp_metabox_longitude%":"-76.0174416","%rank_math_internal_links_processed%":"1"}},"id":2827,"infowindow_disable":false},{"source":"post","title":"Maintenance Planner","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Maintenance Planner\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Key Responsibilities: Maintenance Planning &amp; Scheduling: \uf0a7 Oversee tracking of all equipment. \uf0a7 Schedule, and coordinate planned maintenance (PM) and&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/maintenance-planner\/\" name=\"Maintenance Planner\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Key Responsibilities: Maintenance Planning &amp; Scheduling: \uf0a7 Oversee tracking of all equipment. \uf0a7 Schedule, and coordinate planned maintenance (PM) 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-planner\/","zoom":19,"extra_fields":{"post_excerpt":"Key Responsibilities: Maintenance Planning &amp; Scheduling: \uf0a7 Oversee tracking of all equipment. \uf0a7 Schedule, and coordinate planned maintenance (PM) and&hellip;","post_content":"<p>Key Responsibilities:<\/p>\n<p>Maintenance Planning &amp; Scheduling:<\/p>\n<p>\uf0a7 Oversee tracking of all equipment.<\/p>\n<p>\uf0a7 Schedule, and coordinate planned maintenance (PM) and corrective maintenance (CM) activities.<\/p>\n<p>\uf0a7 Manage and prioritize work orders, ensuring accurate documentation and execution of maintenance and inspection tasks.<\/p>\n<p>\uf0a7 Utilize Equipment Service Requests (ESRs) to plan, track, and close maintenance and service tasks.<\/p>\n<p>\uf0a7 Plan equipment shutdowns and service intervals in collaboration with field operations and drilling schedules.<\/p>\n<p>Service, Work Orders &amp; Inspections<\/p>\n<p>\uf0a7 Schedule and coordinate routine inspections and service intervals, and ensure their completion (e.g., work orders, crane inspections, pressure vessels, fire inspections, DOT and safety compliance).<\/p>\n<p>\uf0a7 Maintain accurate records of all maintenance work performed, including documentation of corrective actions.<\/p>\n<p>\uf0a7 Interface with field personnel and supervisors to gather feedback and adjust schedules as needed.<\/p>\n<p>Inventory &amp; Parts:<\/p>\n<p>\uf0a7 Ensure critical spares and parts are available to support scheduled and unscheduled maintenance.<\/p>\n<p>\uf0a7 Collaborate with supply chain and warehouse teams to maintain accurate inventory levels and forecast usage.<\/p>\n<p>\uf0a7 Provide input on inventory planning, parts kitting, and reorder thresholds based on usage data and failure trends.<\/p>\n<p>Warranty &amp; Component Failure Management<\/p>\n<p>\uf0a7 Track and manage warranty claims for parts and equipment to ensure cost recovery.<\/p>\n<p>\uf0a7 Log and analyze component failures to identify trends, or recurring issues.<\/p>\n<p>Trend Analysis &amp; Reporting<\/p>\n<p>\uf0a7 Monitor and report on premature failure trends.<\/p>\n<p>Equipment Damage Reporting<\/p>\n<p>\uf0a7 Create and distribute Equipment Damage Reports.<\/p>\n<p>\uf0a7 Use damage data to develop prevention strategies and reduce repeat incidents.<\/p>\n<p>Qualifications &amp; Experience:<\/p>\n<p>\uf0a7 Minimum 3-5 years\u2019 experience in maintenance planning, preferably in drilling, oil &amp; gas, or heavy equipment industries.<\/p>\n<p>\uf0a7 Strong knowledge of drilling equipment, hydraulic systems, diesel engines, and rotating equipment.<\/p>\n<p>\uf0a7 Proficient in MS Office Suite. Preferred ERP systems experience.<\/p>\n<p>\uf0a7 Familiarity with warranty management, component lifecycle tracking, and reliability principles.<\/p>\n<p>Skills &amp; Competencies:<\/p>\n<p>\uf0a7 High attention to detail with strong organizational and time management skills.<\/p>\n<p>\uf0a7 Analytical mindset with the ability to identify trends and propose actionable solutions.<\/p>\n<p>\uf0a7 Excellent communication and interpersonal skills for coordination across departments and with external vendors.<\/p>\n<p>\uf0a7 Proactive approach to problem-solving and continuous improvement.<\/p>","post_title":"Maintenance Planner","post_link":"https:\/\/turnerstaffing.com\/position\/maintenance-planner\/","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>Key Responsibilities:<\/p>\n<p>Maintenance Planning &amp; Scheduling:<\/p>\n<p>\uf0a7 Oversee tracking of all equipment.<\/p>\n<p>\uf0a7 Schedule, and coordinate planned maintenance (PM) and corrective maintenance (CM) activities.<\/p>\n<p>\uf0a7 Manage and prioritize work orders, ensuring accurate documentation and execution of maintenance and inspection tasks.<\/p>\n<p>\uf0a7 Utilize Equipment Service Requests (ESRs) to plan, track, and close maintenance and service tasks.<\/p>\n<p>\uf0a7 Plan equipment shutdowns and service intervals in collaboration with field operations and drilling schedules.<\/p>\n<p>Service, Work Orders &amp; Inspections<\/p>\n<p>\uf0a7 Schedule and coordinate routine inspections and service intervals, and ensure their completion (e.g., work orders, crane inspections, pressure vessels, fire inspections, DOT and safety compliance).<\/p>\n<p>\uf0a7 Maintain accurate records of all maintenance work performed, including documentation of corrective actions.<\/p>\n<p>\uf0a7 Interface with field personnel and supervisors to gather feedback and adjust schedules as needed.<\/p>\n<p>Inventory &amp; Parts:<\/p>\n<p>\uf0a7 Ensure critical spares and parts are available to support scheduled and unscheduled maintenance.<\/p>\n<p>\uf0a7 Collaborate with supply chain and warehouse teams to maintain accurate inventory levels and forecast usage.<\/p>\n<p>\uf0a7 Provide input on inventory planning, parts kitting, and reorder thresholds based on usage data and failure trends.<\/p>\n<p>Warranty &amp; Component Failure Management<\/p>\n<p>\uf0a7 Track and manage warranty claims for parts and equipment to ensure cost recovery.<\/p>\n<p>\uf0a7 Log and analyze component failures to identify trends, or recurring issues.<\/p>\n<p>Trend Analysis &amp; Reporting<\/p>\n<p>\uf0a7 Monitor and report on premature failure trends.<\/p>\n<p>Equipment Damage Reporting<\/p>\n<p>\uf0a7 Create and distribute Equipment Damage Reports.<\/p>\n<p>\uf0a7 Use damage data to develop prevention strategies and reduce repeat incidents.<\/p>\n<p>Qualifications &amp; Experience:<\/p>\n<p>\uf0a7 Minimum 3-5 years\u2019 experience in maintenance planning, preferably in drilling, oil &amp; gas, or heavy equipment industries.<\/p>\n<p>\uf0a7 Strong knowledge of drilling equipment, hydraulic systems, diesel engines, and rotating equipment.<\/p>\n<p>\uf0a7 Proficient in MS Office Suite. Preferred ERP systems experience.<\/p>\n<p>\uf0a7 Familiarity with warranty management, component lifecycle tracking, and reliability principles.<\/p>\n<p>Skills &amp; Competencies:<\/p>\n<p>\uf0a7 High attention to detail with strong organizational and time management skills.<\/p>\n<p>\uf0a7 Analytical mindset with the ability to identify trends and propose actionable solutions.<\/p>\n<p>\uf0a7 Excellent communication and interpersonal skills for coordination across departments and with external vendors.<\/p>\n<p>\uf0a7 Proactive approach to problem-solving and continuous improvement.<\/p>","%category%":"Operations","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/92029d768468-maintenance-planner","%breezy_id%":"92029d768468","%breezy_friendly_id%":"92029d768468-maintenance-planner","%breezy_created_date%":"2025-10-13T18:20:07.500Z","%breezy_updated_date%":"2026-01-14T19:20:27.059Z","%_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":2826,"infowindow_disable":false},{"source":"post","title":"Project Manager &#8211; Mining","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Project Manager &#8211; Mining\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Turner Mining Group &#8211;&nbsp;Project Manager&nbsp; A challenging and rewarding opportunity for a senior project manager with experience in the mining&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/project-manager-mining-3\/\" name=\"Project Manager &#8211; Mining\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Turner Mining Group &#8211;&nbsp;Project Manager&nbsp; A challenging and rewarding opportunity for a senior project manager with experience in the mining&hellip;","address":"Midland, TX, USA","location":{"lat":"31.9995797","city":"Midland","state":"TX","country":"United States","lng":"-102.0756701","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/project-manager-mining-3\/","zoom":19,"extra_fields":{"post_excerpt":"Turner Mining Group &#8211;&nbsp;Project Manager&nbsp; A challenging and rewarding opportunity for a senior project manager with experience in the mining&hellip;","post_content":"<p><strong><u>Turner Mining Group -&nbsp;Project Manager&nbsp;<\/u><\/strong><\/p>\n<p>A challenging and rewarding opportunity for a senior project manager with experience in the mining industry!<br><\/p>\n<p>We are looking for a talented Project Manager to lead the development and execution of a large-scale production mining projects. The Project Manager will be responsible for managing the project scope, schedule, budget, quality, safety, and stakeholder relations. The&nbsp;Project Manager&nbsp;will also oversee the engineering, procurement, construction, commissioning, and operation phases of the project.<\/p>\n<p><strong>Responsibilities:<\/strong><br><\/p>\n<ul><li>Develop and implement the project strategy, plan, and governance framework based on data analysis and best practices<\/li><li>Manage the project team and vendors using data-driven tools and metrics<\/li><li>Ensure the project meets the technical, regulatory, and environmental requirements using data validation and verification methods<\/li><li>Monitor and control the project performance, risks, issues, and changes using data visualization and reporting techniques<\/li><li>Report and communicate the project status, progress, and outcomes to the senior management and the client using data storytelling and presentation skills<\/li><li>Ensure the project adheres to the highest standards of health, safety, and quality using data collection and evaluation systems<\/li><li>Facilitate the smooth transition from construction to operation using data integration and automation solutions<\/li><\/ul>\n<p><strong>Qualifications:<\/strong><\/p>\n<ul><li>Bachelor's degree in engineering, project management, or related field<\/li><li>Minimum 10 years of experience in managing large-scale capital projects in the mining industry<\/li><li>Proven track record of delivering projects on time, on budget, and on quality using data-driven approaches<\/li><li>Strong leadership, communication, negotiation, and problem-solving skills with a data-oriented mindset<\/li><li>Ability to work effectively in a fast-paced and dynamic environment with data complexity and uncertainty<\/li><li>Familiarity with the frac sand market and the hydraulic fracturing process and the data sources and standards associated with them<\/li><li>Willingness to travel and relocate as required<\/li><\/ul>\n<p><strong>Benefits:<\/strong><\/p>\n<p>Our client offers a competitive salary, an excellent work culture, career advancement opportunities. Our client offers a benefits program which includes Medical, Dental, Vision, Life, and a 401k with company match.<\/p>\n<p>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":"Project Manager &#8211; Mining","post_link":"https:\/\/turnerstaffing.com\/position\/project-manager-mining-3\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"","%location_country%":"United States","%location_city%":"Midland","%location_state_id%":"TX","%location_state_name%":"Texas","%location_city_state%":"Midland, TX","%education%":"","%department%":"Operations","%description%":"<p><strong><u>Turner Mining Group -&nbsp;Project Manager&nbsp;<\/u><\/strong><\/p>\n<p>A challenging and rewarding opportunity for a senior project manager with experience in the mining industry!<br><\/p>\n<p>We are looking for a talented Project Manager to lead the development and execution of a large-scale production mining projects. The Project Manager will be responsible for managing the project scope, schedule, budget, quality, safety, and stakeholder relations. The&nbsp;Project Manager&nbsp;will also oversee the engineering, procurement, construction, commissioning, and operation phases of the project.<\/p>\n<p><strong>Responsibilities:<\/strong><br><\/p>\n<ul><li>Develop and implement the project strategy, plan, and governance framework based on data analysis and best practices<\/li><li>Manage the project team and vendors using data-driven tools and metrics<\/li><li>Ensure the project meets the technical, regulatory, and environmental requirements using data validation and verification methods<\/li><li>Monitor and control the project performance, risks, issues, and changes using data visualization and reporting techniques<\/li><li>Report and communicate the project status, progress, and outcomes to the senior management and the client using data storytelling and presentation skills<\/li><li>Ensure the project adheres to the highest standards of health, safety, and quality using data collection and evaluation systems<\/li><li>Facilitate the smooth transition from construction to operation using data integration and automation solutions<\/li><\/ul>\n<p><strong>Qualifications:<\/strong><\/p>\n<ul><li>Bachelor's degree in engineering, project management, or related field<\/li><li>Minimum 10 years of experience in managing large-scale capital projects in the mining industry<\/li><li>Proven track record of delivering projects on time, on budget, and on quality using data-driven approaches<\/li><li>Strong leadership, communication, negotiation, and problem-solving skills with a data-oriented mindset<\/li><li>Ability to work effectively in a fast-paced and dynamic environment with data complexity and uncertainty<\/li><li>Familiarity with the frac sand market and the hydraulic fracturing process and the data sources and standards associated with them<\/li><li>Willingness to travel and relocate as required<\/li><\/ul>\n<p><strong>Benefits:<\/strong><\/p>\n<p>Our client offers a competitive salary, an excellent work culture, career advancement opportunities. Our client offers a benefits program which includes Medical, Dental, Vision, Life, and a 401k with company match.<\/p>\n<p>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%":"","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/c6399061e51d-project-manager-mining","%breezy_id%":"c6399061e51d","%breezy_friendly_id%":"c6399061e51d-project-manager-mining","%breezy_created_date%":"2023-12-19T13:34:24.180Z","%breezy_updated_date%":"2025-10-17T14:57:04.696Z","%_wpgmp_location_city%":"Midland","%_wpgmp_location_state%":"TX","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Midland, TX, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"31.9995797","%_wpgmp_metabox_longitude%":"-102.0756701","%rank_math_internal_links_processed%":"1"}},"id":2821,"infowindow_disable":false},{"source":"post","title":"Industrial Electrician- Oil &amp; Gas","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Industrial Electrician- Oil &amp; Gas\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Job Description: We are seeking a skilled and dedicated Oil &amp; Gas Electrician to join our team. The ideal candidate&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/industrial-electrician-oil-gas\/\" name=\"Industrial Electrician- Oil &amp; Gas\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Job Description: We are seeking a skilled and dedicated Oil &amp; Gas Electrician to join our team. The ideal candidate&hellip;","address":"Wyalusing, PA, USA","location":{"lat":"41.6681309","city":"Wyalusing","state":"PA","country":"United States","lng":"-76.2618786","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/industrial-electrician-oil-gas\/","zoom":19,"extra_fields":{"post_excerpt":"Job Description: We are seeking a skilled and dedicated Oil &amp; Gas Electrician to join our team. The ideal candidate&hellip;","post_content":"<p>Job Description:<\/p>\n<p>We are seeking a skilled and dedicated Oil &amp; Gas Electrician to join our team. The ideal<\/p>\n<p>candidate will have a strong work ethic, attention to detail and the ability to work well in<\/p>\n<p>a team-oriented environment.<\/p>\n<p>Responsibilities:<\/p>\n<p>- Install, maintain, and repair electrical systems in Oil &amp; Gas and Industrial settings.<\/p>\n<p>- Bend and Install Conduit - Install Rigid Conduit<\/p>\n<p>- Install Electric Heat Trace<\/p>\n<p>- Install Cable Tray<\/p>\n<p>- Install and Terminate Wiring for Devices<\/p>\n<p>- Willing to work 60 Hours Per Week<\/p>\n<p>- Ensure all work is performed in accordance with relevant codes and safety standards.<\/p>\n<p>- Troubleshoot electrical issues and perform necessary repairs.<\/p>\n<p>- Collaborate with team members to complete projects efficiently and effectively.<\/p>\n<p>- Maintain a clean and organized work area.<\/p>\n<p>- Provide exceptional customer service and maintain positive client relationships.<\/p>\n<p>Qualifications:<\/p>\n<p>- Valid driver's license required<\/p>\n<p>- Minimum Two Years of Electrical experience in the Oil &amp; Gas Field<\/p>\n<p>- Proven experience as a commercial or industrial electrician<\/p>\n<p>- Strong understanding of electrical systems and safety procedures<\/p>\n<p>- Excellent problem-solving skills and attention to detail<\/p>\n<p>- Ability to work independently and as part of a team<\/p>\n<p>- Trustworthy, reliable and takes pride in their work<\/p>\n<p>- Positive attitude and the ability to fit into our company culture<\/p>","post_title":"Industrial Electrician- Oil &amp; Gas","post_link":"https:\/\/turnerstaffing.com\/position\/industrial-electrician-oil-gas\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Mid Level","%location_country%":"United States","%location_city%":"Wyalusing","%location_state_id%":"PA","%location_state_name%":"Pennsylvania","%location_city_state%":"Wyalusing, PA","%education%":"Unspecified","%department%":"","%description%":"<p>Job Description:<\/p>\n<p>We are seeking a skilled and dedicated Oil &amp; Gas Electrician to join our team. The ideal<\/p>\n<p>candidate will have a strong work ethic, attention to detail and the ability to work well in<\/p>\n<p>a team-oriented environment.<\/p>\n<p>Responsibilities:<\/p>\n<p>- Install, maintain, and repair electrical systems in Oil &amp; Gas and Industrial settings.<\/p>\n<p>- Bend and Install Conduit - Install Rigid Conduit<\/p>\n<p>- Install Electric Heat Trace<\/p>\n<p>- Install Cable Tray<\/p>\n<p>- Install and Terminate Wiring for Devices<\/p>\n<p>- Willing to work 60 Hours Per Week<\/p>\n<p>- Ensure all work is performed in accordance with relevant codes and safety standards.<\/p>\n<p>- Troubleshoot electrical issues and perform necessary repairs.<\/p>\n<p>- Collaborate with team members to complete projects efficiently and effectively.<\/p>\n<p>- Maintain a clean and organized work area.<\/p>\n<p>- Provide exceptional customer service and maintain positive client relationships.<\/p>\n<p>Qualifications:<\/p>\n<p>- Valid driver's license required<\/p>\n<p>- Minimum Two Years of Electrical experience in the Oil &amp; Gas Field<\/p>\n<p>- Proven experience as a commercial or industrial electrician<\/p>\n<p>- Strong understanding of electrical systems and safety procedures<\/p>\n<p>- Excellent problem-solving skills and attention to detail<\/p>\n<p>- Ability to work independently and as part of a team<\/p>\n<p>- Trustworthy, reliable and takes pride in their work<\/p>\n<p>- Positive attitude and the ability to fit into our company culture<\/p>","%category%":"Operations","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/19a197bb5459-industrial-electrician-oil-gas","%breezy_id%":"19a197bb5459","%breezy_friendly_id%":"19a197bb5459-industrial-electrician-oil-gas","%breezy_created_date%":"2025-10-09T17:11:19.014Z","%breezy_updated_date%":"2026-01-14T19:18:19.174Z","%_wpgmp_location_city%":"Wyalusing","%_wpgmp_location_state%":"PA","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Wyalusing, PA, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"41.6681309","%_wpgmp_metabox_longitude%":"-76.2618786","%rank_math_internal_links_processed%":"1"}},"id":2816,"infowindow_disable":false},{"source":"post","title":"Civil Construction Superintendent","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Civil Construction Superintendent\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    The General Superintendent manages all civil construction projects and oversees their progress along the way in a timely and cost-effective&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/civil-construction-superintendent\/\" name=\"Civil Construction Superintendent\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"The General Superintendent manages all civil construction projects and oversees their progress along the way in a timely and cost-effective&hellip;","address":"Old Lyme, CT, USA","location":{"lat":"41.3162037","city":"Old Lyme","state":"CT","country":"United States","lng":"-72.329796","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/civil-construction-superintendent\/","zoom":19,"extra_fields":{"post_excerpt":"The General Superintendent manages all civil construction projects and oversees their progress along the way in a timely and cost-effective&hellip;","post_content":"<p>The General Superintendent manages all civil construction projects and oversees their progress along the way in a timely and cost-effective manner. You will be responsible for budgeting, organization, implementation and scheduling of the projects.<\/p>\n<p><strong>Duties and responsibilities<\/strong><\/p>\n<ul><li>Oversee and direct civil construction projects from conception to completion<\/li><li>Review the project in-depth to schedule deliverables and estimate costs<\/li><li>Oversee all onsite and offsite civil construction projects to monitor compliance with building and safety regulations<\/li><li>Coordinate and direct construction workers and subcontractors<\/li><li>Select tools, materials and equipment and track inventory<\/li><li>Oversee and schedule manpower on multiple sites<\/li><li>Meet contractual conditions of performance<\/li><li>Review the work progress on daily basis<\/li><li>Prepare internal and external reports pertaining to job status<\/li><li>Plan ahead to prevent problems and resolve any emerging ones<\/li><li>Negotiate terms of purchasing agreements coordinate material delivery with Project manager<\/li><li>Analyze, manage and mitigate risks<\/li><li>Ensure quality construction standards and the use of proper construction techniques<\/li><li>Communicate project status and schedule to the office for proper planning<\/li><\/ul>\n<p><strong>Qualifications<\/strong><\/p>\n<ul><li>Proven working experience in civil construction management<\/li><li>Advanced knowledge of civil construction management processes, means and methods<\/li><li>Expert knowledge of building products, civil construction details and relevant rules, regulations and quality standards<\/li><li>Understanding of all facets of the civil construction process<\/li><li>Familiarity with civil construction management software packages<\/li><li>Ability to plan and see the \u201cbig picture\u201d<\/li><li>Competent in conflict and crisis management<\/li><li>Leadership and human resources management skills<\/li><li>Excellent time and project management skills<\/li><li>BS degree in construction management, architecture, engineering or related field<\/li><li>Travel is required for onsite meetings and daily coordination<\/li><\/ul>","post_title":"Civil Construction Superintendent","post_link":"https:\/\/turnerstaffing.com\/position\/civil-construction-superintendent\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"","%location_country%":"United States","%location_city%":"Old Lyme","%location_state_id%":"CT","%location_state_name%":"Connecticut","%location_city_state%":"Old Lyme, CT","%education%":"","%department%":"","%description%":"<p>The General Superintendent manages all civil construction projects and oversees their progress along the way in a timely and cost-effective manner. You will be responsible for budgeting, organization, implementation and scheduling of the projects.<\/p>\n<p><strong>Duties and responsibilities<\/strong><\/p>\n<ul><li>Oversee and direct civil construction projects from conception to completion<\/li><li>Review the project in-depth to schedule deliverables and estimate costs<\/li><li>Oversee all onsite and offsite civil construction projects to monitor compliance with building and safety regulations<\/li><li>Coordinate and direct construction workers and subcontractors<\/li><li>Select tools, materials and equipment and track inventory<\/li><li>Oversee and schedule manpower on multiple sites<\/li><li>Meet contractual conditions of performance<\/li><li>Review the work progress on daily basis<\/li><li>Prepare internal and external reports pertaining to job status<\/li><li>Plan ahead to prevent problems and resolve any emerging ones<\/li><li>Negotiate terms of purchasing agreements coordinate material delivery with Project manager<\/li><li>Analyze, manage and mitigate risks<\/li><li>Ensure quality construction standards and the use of proper construction techniques<\/li><li>Communicate project status and schedule to the office for proper planning<\/li><\/ul>\n<p><strong>Qualifications<\/strong><\/p>\n<ul><li>Proven working experience in civil construction management<\/li><li>Advanced knowledge of civil construction management processes, means and methods<\/li><li>Expert knowledge of building products, civil construction details and relevant rules, regulations and quality standards<\/li><li>Understanding of all facets of the civil construction process<\/li><li>Familiarity with civil construction management software packages<\/li><li>Ability to plan and see the \u201cbig picture\u201d<\/li><li>Competent in conflict and crisis management<\/li><li>Leadership and human resources management skills<\/li><li>Excellent time and project management skills<\/li><li>BS degree in construction management, architecture, engineering or related field<\/li><li>Travel is required for onsite meetings and daily coordination<\/li><\/ul>","%category%":"Operations","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/8e26a6221060-civil-construction-superintendent","%breezy_id%":"8e26a6221060","%breezy_friendly_id%":"8e26a6221060-civil-construction-superintendent","%breezy_created_date%":"2025-10-07T17:35:29.452Z","%breezy_updated_date%":"2026-01-14T19:05:55.483Z","%_wpgmp_location_city%":"Old Lyme","%_wpgmp_location_state%":"CT","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Old Lyme, CT, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"41.3162037","%_wpgmp_metabox_longitude%":"-72.329796","%rank_math_internal_links_processed%":"1"}},"id":2813,"infowindow_disable":false},{"source":"post","title":"Project Manager","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Project Manager\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Busy heavy civil site construction company is looking for an experienced Project Manager. The ideal candidate should have at least&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/project-manager-2\/\" name=\"Project Manager\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Busy heavy civil site construction company is looking for an experienced Project Manager. The ideal candidate should have at least&hellip;","address":"Old Lyme, CT, USA","location":{"lat":"41.3162037","city":"Old Lyme","state":"CT","country":"United States","lng":"-72.329796","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/project-manager-2\/","zoom":19,"extra_fields":{"post_excerpt":"Busy heavy civil site construction company is looking for an experienced Project Manager. The ideal candidate should have at least&hellip;","post_content":"<p><\/p><p>Busy heavy civil site construction company is looking for an experienced Project Manager. The ideal candidate should have at least 3 years experience in heavy civil site construction project management, and have experience working with the CT DOT.<\/p>\n<p><strong>Responsibilities Include:<\/strong><\/p>\n<ul><li>Collaborate with engineers, architects, CMs<\/li><li>Determine needed resources i.e. manpower, equipment, and materials<\/li><li>Obtain permits<\/li><li>Maintain project schedules<\/li><li>Preparation of purchase orders<\/li><li>Prepare and review submittals and shop drawings<\/li><li>Project organization<\/li><li>Request RFIs<\/li><li>Coordinate submittals by other trades<\/li><li>Project Closeout<\/li><li>Track punch list and ensure items are complete<\/li><\/ul>\n<p><strong>Qualifications:<\/strong><\/p>\n<ul><li>3-5 years of relevant experience<\/li><li>Knowledge of CT DOT submittal process<\/li><li>Proficiency with blueprint reading and mechanical drawings<\/li><li>Able to perform take-offs, measuring, and provide material lists<\/li><li>Degree in civil, architecture, mechanical engineering, building construction, or related field preferred but not required<\/li><li>Strong interpersonal, communication and writing skills, extreme attention to detail and ability to manage multiple tasks<\/li><li>MS Office experience required<\/li><\/ul><p><\/p>","post_title":"Project Manager","post_link":"https:\/\/turnerstaffing.com\/position\/project-manager-2\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"","%location_country%":"United States","%location_city%":"Old Lyme","%location_state_id%":"CT","%location_state_name%":"Connecticut","%location_city_state%":"Old Lyme, CT","%education%":"","%department%":"","%description%":"<p><\/p><p>Busy heavy civil site construction company is looking for an experienced Project Manager. The ideal candidate should have at least 3 years experience in heavy civil site construction project management, and have experience working with the CT DOT.<\/p>\n<p><strong>Responsibilities Include:<\/strong><\/p>\n<ul><li>Collaborate with engineers, architects, CMs<\/li><li>Determine needed resources i.e. manpower, equipment, and materials<\/li><li>Obtain permits<\/li><li>Maintain project schedules<\/li><li>Preparation of purchase orders<\/li><li>Prepare and review submittals and shop drawings<\/li><li>Project organization<\/li><li>Request RFIs<\/li><li>Coordinate submittals by other trades<\/li><li>Project Closeout<\/li><li>Track punch list and ensure items are complete<\/li><\/ul>\n<p><strong>Qualifications:<\/strong><\/p>\n<ul><li>3-5 years of relevant experience<\/li><li>Knowledge of CT DOT submittal process<\/li><li>Proficiency with blueprint reading and mechanical drawings<\/li><li>Able to perform take-offs, measuring, and provide material lists<\/li><li>Degree in civil, architecture, mechanical engineering, building construction, or related field preferred but not required<\/li><li>Strong interpersonal, communication and writing skills, extreme attention to detail and ability to manage multiple tasks<\/li><li>MS Office experience required<\/li><\/ul><p><\/p>","%category%":"Operations","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/be06afab5bf4-project-manager","%breezy_id%":"be06afab5bf4","%breezy_friendly_id%":"be06afab5bf4-project-manager","%breezy_created_date%":"2025-10-07T17:44:26.016Z","%breezy_updated_date%":"2026-01-14T19:25:16.972Z","%_wpgmp_location_city%":"Old Lyme","%_wpgmp_location_state%":"CT","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Old Lyme, CT, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"41.3162037","%_wpgmp_metabox_longitude%":"-72.329796","%rank_math_internal_links_processed%":"1"}},"id":2814,"infowindow_disable":false},{"source":"post","title":"Paving Foreman","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Paving Foreman\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    The Paving Foreman will play a pivotal role in overseeing and managing all aspects of paving operations on construction sites.&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/paving-foreman-2\/\" name=\"Paving Foreman\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"The Paving Foreman will play a pivotal role in overseeing and managing all aspects of paving operations on construction sites.&hellip;","address":"Chesapeake, VA, USA","location":{"lat":"36.7682088","city":"Chesapeake","state":"VA","country":"United States","lng":"-76.2874927","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/paving-foreman-2\/","zoom":19,"extra_fields":{"post_excerpt":"The Paving Foreman will play a pivotal role in overseeing and managing all aspects of paving operations on construction sites.&hellip;","post_content":"<p>The Paving Foreman will play a pivotal role in overseeing and managing all aspects of paving operations on construction sites. The ideal candidate will have a strong background in paving techniques, materials, equipment operation, team leadership, and safety protocols. The Paving Foreman will collaborate closely with project managers, engineers, and field staff to ensure the successful completion of paving projects within established timelines and quality standards. They will be responsible for supervising and directing assigned crew members in preparing, executing, and finishing asphalt paving projects.<\/p>\n<p><\/p>\n<p>This role is fast paced and requires someone who can take ownership of their work, make informed decisions, and coordinate with and direct the activities of all job site crews, subcontractors, and material and equipment providers. Additionally, the candidate must effectively interface with clients, inspectors, regulatory representatives, and other key individuals within the organization.<\/p>\n<p><\/p>\n<p><em>Responsibilities:&nbsp;<\/em><\/p>\n<ul><li>Demonstrates technical proficiency in multiple aspects of asphalt paving.<\/li><li>Supervises hourly crewmembers and plans\/schedules manpower and equipment as needed.<\/li><li>Manages deliveries from suppliers and subcontractors to ensure safety, profit, scheduling compliance and customer satisfaction.<\/li><li>Follows our client's Safety Program including preplanning to identify conditions and exposures, proper safety and personal protective equipment and accident investigation and reporting.<\/li><li>Coordinates and collaborates with other Foremen, Superintendents, and the customer to implement successful project plans.<\/li><li>Provides on the job training to crewmembers for assigned tasks.<\/li><li>Communicates performance expectations for productivity, quality, and safety to crews and ensures progress towards expectations.<\/li><li>Administers timely and accurate documentation for project-related activities including change orders, time and materials, purchase orders, daily job control reports and receiving slips\/invoices.<\/li><\/ul>\n<h2>Qualifications<\/h2>\n<ul><li>High school diploma or equivalent (GED) required (continuing education in construction highly desirable).<\/li><li>Minimum 2 years of heavy highway, asphalt paving&nbsp;experience.<\/li><li>OSHA 10 hour required.<\/li><li>Valid driver\u2019s license required<\/li><\/ul>","post_title":"Paving Foreman","post_link":"https:\/\/turnerstaffing.com\/position\/paving-foreman-2\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Mid Level","%location_country%":"United States","%location_city%":"Chesapeake","%location_state_id%":"VA","%location_state_name%":"Virginia","%location_city_state%":"Chesapeake, VA","%education%":"High School or Equivalent","%department%":"","%description%":"<p>The Paving Foreman will play a pivotal role in overseeing and managing all aspects of paving operations on construction sites. The ideal candidate will have a strong background in paving techniques, materials, equipment operation, team leadership, and safety protocols. The Paving Foreman will collaborate closely with project managers, engineers, and field staff to ensure the successful completion of paving projects within established timelines and quality standards. They will be responsible for supervising and directing assigned crew members in preparing, executing, and finishing asphalt paving projects.<\/p>\n<p><\/p>\n<p>This role is fast paced and requires someone who can take ownership of their work, make informed decisions, and coordinate with and direct the activities of all job site crews, subcontractors, and material and equipment providers. Additionally, the candidate must effectively interface with clients, inspectors, regulatory representatives, and other key individuals within the organization.<\/p>\n<p><\/p>\n<p><em>Responsibilities:&nbsp;<\/em><\/p>\n<ul><li>Demonstrates technical proficiency in multiple aspects of asphalt paving.<\/li><li>Supervises hourly crewmembers and plans\/schedules manpower and equipment as needed.<\/li><li>Manages deliveries from suppliers and subcontractors to ensure safety, profit, scheduling compliance and customer satisfaction.<\/li><li>Follows our client's Safety Program including preplanning to identify conditions and exposures, proper safety and personal protective equipment and accident investigation and reporting.<\/li><li>Coordinates and collaborates with other Foremen, Superintendents, and the customer to implement successful project plans.<\/li><li>Provides on the job training to crewmembers for assigned tasks.<\/li><li>Communicates performance expectations for productivity, quality, and safety to crews and ensures progress towards expectations.<\/li><li>Administers timely and accurate documentation for project-related activities including change orders, time and materials, purchase orders, daily job control reports and receiving slips\/invoices.<\/li><\/ul>\n<h2>Qualifications<\/h2>\n<ul><li>High school diploma or equivalent (GED) required (continuing education in construction highly desirable).<\/li><li>Minimum 2 years of heavy highway, asphalt paving&nbsp;experience.<\/li><li>OSHA 10 hour required.<\/li><li>Valid driver\u2019s license required<\/li><\/ul>","%category%":"Management","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/17326c5917ec-paving-foreman","%breezy_id%":"17326c5917ec","%breezy_friendly_id%":"17326c5917ec-paving-foreman","%breezy_created_date%":"2025-09-25T13:39:01.061Z","%breezy_updated_date%":"2026-01-14T19:23:47.663Z","%_wpgmp_location_city%":"Chesapeake","%_wpgmp_location_state%":"VA","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Chesapeake, VA, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"36.7682088","%_wpgmp_metabox_longitude%":"-76.2874927","%rank_math_internal_links_processed%":"1"}},"id":2784,"infowindow_disable":false},{"source":"post","title":"Pipe Layer","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Pipe Layer\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Are you hungry \/ humble \/ smart? Do you think differently? Are you ready to find an opportunity that offers&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/pipe-layer\/\" name=\"Pipe Layer\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Are you hungry \/ humble \/ smart? Do you think differently? Are you ready to find an opportunity that offers&hellip;","address":"Lancaster, PA, USA","location":{"lat":"40.0403279","city":"Lancaster","state":"PA","country":"United States","lng":"-76.3041833","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/pipe-layer\/","zoom":19,"extra_fields":{"post_excerpt":"Are you hungry \/ humble \/ smart? Do you think differently? Are you ready to find an opportunity that offers&hellip;","post_content":"<p>Are you hungry \/ humble \/ smart? Do you think differently? Are you ready to find an opportunity that offers REAL growth?<\/p>\n<p>We\u2019ve been waiting for you!<br><\/p>\n<p><strong>You<\/strong><\/p>\n<p>You want to work for a services company that is rapidly changing the way the way pipe work is conducted. 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 pipe rehabilitation, 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><li>Willingness to learn operating equipment<\/li><li>Team Player with GREAT attitude!<\/li><\/ul>\n<p><strong>Requirements:<\/strong><\/p>\n<ul><li>Driver's License<\/li><li>Safety oriented, awareness of everyone and everything that is around you<\/li><li>Knowledge of DOT Regulations<\/li><li>Experience in heavy highway utility work&nbsp;<\/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><\/ul>","post_title":"Pipe Layer","post_link":"https:\/\/turnerstaffing.com\/position\/pipe-layer\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Associate","%location_country%":"United States","%location_city%":"Lancaster","%location_state_id%":"PA","%location_state_name%":"Pennsylvania","%location_city_state%":"Lancaster, PA","%education%":"Unspecified","%department%":"","%description%":"<p>Are you hungry \/ humble \/ smart? Do you think differently? Are you ready to find an opportunity that offers REAL growth?<\/p>\n<p>We\u2019ve been waiting for you!<br><\/p>\n<p><strong>You<\/strong><\/p>\n<p>You want to work for a services company that is rapidly changing the way the way pipe work is conducted. 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 pipe rehabilitation, 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><li>Willingness to learn operating equipment<\/li><li>Team Player with GREAT attitude!<\/li><\/ul>\n<p><strong>Requirements:<\/strong><\/p>\n<ul><li>Driver's License<\/li><li>Safety oriented, awareness of everyone and everything that is around you<\/li><li>Knowledge of DOT Regulations<\/li><li>Experience in heavy highway utility work&nbsp;<\/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><\/ul>","%category%":"Operations","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/fb9406690f01-pipe-layer","%breezy_id%":"fb9406690f01","%breezy_friendly_id%":"fb9406690f01-pipe-layer","%breezy_created_date%":"2025-04-07T16:26:31.431Z","%breezy_updated_date%":"2025-11-14T20:43:39.779Z","%_wpgmp_location_city%":"Lancaster","%_wpgmp_location_state%":"PA","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Lancaster, PA, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"40.0403279","%_wpgmp_metabox_longitude%":"-76.3041833","%rank_math_internal_links_processed%":"1"}},"id":2783,"infowindow_disable":false},{"source":"post","title":"Grader Operator","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Grader Operator\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Turner Staffing Group \u2013 Grader Operator Do you love the dirt world? Do you think differently? Are you ready to&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/grader-operator\/\" name=\"Grader Operator\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Turner Staffing Group \u2013 Grader Operator Do you love the dirt world? Do you think differently? Are you ready to&hellip;","address":"Scranton, PA, USA","location":{"lat":"41.410314","city":"Scranton","state":"PA","country":"United States","lng":"-75.661099","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/grader-operator\/","zoom":19,"extra_fields":{"post_excerpt":"Turner Staffing Group \u2013 Grader Operator Do you love the dirt world? Do you think differently? Are you ready to&hellip;","post_content":"<p><strong><u>Turner Staffing Group \u2013 Grader Operator<\/u><\/strong><\/p>\n<p>Do you love the dirt world? 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 civil construction 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 Grader Operators for our fast-growing, forward thinking client based in the Scranton area.<br><\/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 construction firms 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 graders in a civil construction 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 OSHA training<\/li><\/ul>","post_title":"Grader Operator","post_link":"https:\/\/turnerstaffing.com\/position\/grader-operator\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Mid Level","%location_country%":"United States","%location_city%":"Scranton","%location_state_id%":"PA","%location_state_name%":"Pennsylvania","%location_city_state%":"Scranton, PA","%education%":"Unspecified","%department%":"","%description%":"<p><strong><u>Turner Staffing Group \u2013 Grader Operator<\/u><\/strong><\/p>\n<p>Do you love the dirt world? 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 civil construction 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 Grader Operators for our fast-growing, forward thinking client based in the Scranton area.<br><\/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 construction firms 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 graders in a civil construction 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 OSHA training<\/li><\/ul>","%category%":"Operations","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/f50a8f0e9925-grader-operator","%breezy_id%":"f50a8f0e9925","%breezy_friendly_id%":"f50a8f0e9925-grader-operator","%breezy_created_date%":"2025-04-03T18:55:19.763Z","%breezy_updated_date%":"2026-01-14T19:13:45.072Z","%_wpgmp_location_city%":"Scranton","%_wpgmp_location_state%":"PA","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Scranton, PA, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"41.410314","%_wpgmp_metabox_longitude%":"-75.661099","%rank_math_internal_links_processed%":"1"}},"id":2777,"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 Staffing Group \u2013 Haul Truck Driver Do you love the dirt world? Do you think differently? Are you ready&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/haul-truck-driver-13\/\" name=\"Haul Truck Driver\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Turner Staffing Group \u2013 Haul Truck Driver Do you love the dirt world? Do you think differently? Are you ready&hellip;","address":"Scranton, PA, USA","location":{"lat":"41.410314","city":"Scranton","state":"PA","country":"United States","lng":"-75.661099","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/haul-truck-driver-13\/","zoom":19,"extra_fields":{"post_excerpt":"Turner Staffing Group \u2013 Haul Truck Driver Do you love the dirt world? Do you think differently? Are you ready&hellip;","post_content":"<p><strong><u>Turner Staffing Group \u2013 Haul Truck Driver<\/u><\/strong><\/p>\n<p>Do you love the dirt world? 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 civil construction 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 Haul Truck Drivers for our fast-growing, forward thinking client based in the Scranton area.<br><\/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 construction firms 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 haul trucks in a civil construction 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 OSHA training<\/li><\/ul>","post_title":"Haul Truck Driver","post_link":"https:\/\/turnerstaffing.com\/position\/haul-truck-driver-13\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Mid Level","%location_country%":"United States","%location_city%":"Scranton","%location_state_id%":"PA","%location_state_name%":"Pennsylvania","%location_city_state%":"Scranton, PA","%education%":"Unspecified","%department%":"","%description%":"<p><strong><u>Turner Staffing Group \u2013 Haul Truck Driver<\/u><\/strong><\/p>\n<p>Do you love the dirt world? 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 civil construction 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 Haul Truck Drivers for our fast-growing, forward thinking client based in the Scranton area.<br><\/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 construction firms 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 haul trucks in a civil construction 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 OSHA training<\/li><\/ul>","%category%":"Operations","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/6e43f77d261e-haul-truck-driver","%breezy_id%":"6e43f77d261e","%breezy_friendly_id%":"6e43f77d261e-haul-truck-driver","%breezy_created_date%":"2025-04-03T18:56:29.561Z","%breezy_updated_date%":"2026-01-14T19:14:31.040Z","%_wpgmp_location_city%":"Scranton","%_wpgmp_location_state%":"PA","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Scranton, PA, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"41.410314","%_wpgmp_metabox_longitude%":"-75.661099","%rank_math_internal_links_processed%":"1"}},"id":2778,"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 Staffing Group \u2013 Dozer Operator Do you love the dirt world? Do you think differently? Are you ready to&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/dozer-operator-7\/\" name=\"Dozer Operator\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Turner Staffing Group \u2013 Dozer Operator Do you love the dirt world? Do you think differently? Are you ready to&hellip;","address":"Scranton, PA, USA","location":{"lat":"41.410314","city":"Scranton","state":"PA","country":"United States","lng":"-75.661099","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/dozer-operator-7\/","zoom":19,"extra_fields":{"post_excerpt":"Turner Staffing Group \u2013 Dozer Operator Do you love the dirt world? Do you think differently? Are you ready to&hellip;","post_content":"<p><strong><u>Turner Staffing Group \u2013 Dozer Operator<\/u><\/strong><\/p>\n<p>Do you love the dirt world? 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 civil construction&nbsp;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 Dozer Operators for our fast-growing, forward thinking client based&nbsp;in the Scranton area.<br><\/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 construction firms&nbsp;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 excavators in a civil construction&nbsp;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 OSHA training<\/li><\/ul>","post_title":"Dozer Operator","post_link":"https:\/\/turnerstaffing.com\/position\/dozer-operator-7\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Mid Level","%location_country%":"United States","%location_city%":"Scranton","%location_state_id%":"PA","%location_state_name%":"Pennsylvania","%location_city_state%":"Scranton, PA","%education%":"Unspecified","%department%":"","%description%":"<p><strong><u>Turner Staffing Group \u2013 Dozer Operator<\/u><\/strong><\/p>\n<p>Do you love the dirt world? 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 civil construction&nbsp;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 Dozer Operators for our fast-growing, forward thinking client based&nbsp;in the Scranton area.<br><\/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 construction firms&nbsp;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 excavators in a civil construction&nbsp;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 OSHA training<\/li><\/ul>","%category%":"Operations","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/ce8924b823bc-dozer-operator","%breezy_id%":"ce8924b823bc","%breezy_friendly_id%":"ce8924b823bc-dozer-operator","%breezy_created_date%":"2025-04-03T18:30:05.657Z","%breezy_updated_date%":"2026-01-14T19:07:52.177Z","%_wpgmp_location_city%":"Scranton","%_wpgmp_location_state%":"PA","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Scranton, PA, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"41.410314","%_wpgmp_metabox_longitude%":"-75.661099","%rank_math_internal_links_processed%":"1"}},"id":2774,"infowindow_disable":false},{"source":"post","title":"Construction Laborer","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Construction Laborer\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Turner Staffing Group \u2013 Construction Laborer Do you love the dirt world? Do you think differently? Are you ready to&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/construction-laborer-2\/\" name=\"Construction Laborer\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Turner Staffing Group \u2013 Construction Laborer Do you love the dirt world? Do you think differently? Are you ready to&hellip;","address":"Scranton, PA, USA","location":{"lat":"41.410314","city":"Scranton","state":"PA","country":"United States","lng":"-75.661099","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/construction-laborer-2\/","zoom":19,"extra_fields":{"post_excerpt":"Turner Staffing Group \u2013 Construction Laborer Do you love the dirt world? Do you think differently? Are you ready to&hellip;","post_content":"<p><strong><u>Turner Staffing Group \u2013 Construction Laborer<\/u><\/strong><\/p>\n<p>Do you love the dirt world? 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 civil construction 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 Construction Laborers for our fast-growing, forward thinking client based in the Scranton area.<br><\/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 construction firms 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 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>Performing tasks as directed by management&nbsp;in a civil construction environment<\/li><li>Assist in basic maintenance and upkeep of equipment<\/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 is a plus<\/li><li>Preferred to have OSHA training<\/li><\/ul>","post_title":"Construction Laborer","post_link":"https:\/\/turnerstaffing.com\/position\/construction-laborer-2\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Associate","%location_country%":"United States","%location_city%":"Scranton","%location_state_id%":"PA","%location_state_name%":"Pennsylvania","%location_city_state%":"Scranton, PA","%education%":"Unspecified","%department%":"","%description%":"<p><strong><u>Turner Staffing Group \u2013 Construction Laborer<\/u><\/strong><\/p>\n<p>Do you love the dirt world? 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 civil construction 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 Construction Laborers for our fast-growing, forward thinking client based in the Scranton area.<br><\/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 construction firms 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 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>Performing tasks as directed by management&nbsp;in a civil construction environment<\/li><li>Assist in basic maintenance and upkeep of equipment<\/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 is a plus<\/li><li>Preferred to have OSHA training<\/li><\/ul>","%category%":"Operations","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/aecf8d1a87ba-construction-laborer","%breezy_id%":"aecf8d1a87ba","%breezy_friendly_id%":"aecf8d1a87ba-construction-laborer","%breezy_created_date%":"2025-04-03T18:31:18.437Z","%breezy_updated_date%":"2026-01-14T19:06:51.753Z","%_wpgmp_location_city%":"Scranton","%_wpgmp_location_state%":"PA","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Scranton, PA, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"41.410314","%_wpgmp_metabox_longitude%":"-75.661099","%rank_math_internal_links_processed%":"1"}},"id":2775,"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 Staffing Group \u2013 Excavator Operator Do you love the dirt world? Do you think differently? Are you ready to&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 Staffing Group \u2013 Excavator Operator Do you love the dirt world? Do you think differently? Are you ready to&hellip;","address":"Scranton, PA, USA","location":{"lat":"41.410314","city":"Scranton","state":"PA","country":"United States","lng":"-75.661099","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/excavator-operator-6\/","zoom":19,"extra_fields":{"post_excerpt":"Turner Staffing Group \u2013 Excavator Operator Do you love the dirt world? Do you think differently? Are you ready to&hellip;","post_content":"<p><strong><u>Turner Staffing Group \u2013 Excavator Operator<\/u><\/strong><\/p>\n<p>Do you love the dirt world? 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 civil construction&nbsp;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 Excavator Operators for our fast-growing, forward thinking client based in the Scranton area.<br><\/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 construction firms 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 excavators in a civil construction 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 OSHA training<\/li><\/ul>","post_title":"Excavator Operator","post_link":"https:\/\/turnerstaffing.com\/position\/excavator-operator-6\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Mid Level","%location_country%":"United States","%location_city%":"Scranton","%location_state_id%":"PA","%location_state_name%":"Pennsylvania","%location_city_state%":"Scranton, PA","%education%":"Unspecified","%department%":"","%description%":"<p><strong><u>Turner Staffing Group \u2013 Excavator Operator<\/u><\/strong><\/p>\n<p>Do you love the dirt world? 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 civil construction&nbsp;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 Excavator Operators for our fast-growing, forward thinking client based in the Scranton area.<br><\/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 construction firms 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 excavators in a civil construction 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 OSHA training<\/li><\/ul>","%category%":"Operations","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/0eeb34ce4b7d-excavator-operator","%breezy_id%":"0eeb34ce4b7d","%breezy_friendly_id%":"0eeb34ce4b7d-excavator-operator","%breezy_created_date%":"2025-04-03T18:53:41.068Z","%breezy_updated_date%":"2026-01-14T19:10:48.049Z","%_wpgmp_location_city%":"Scranton","%_wpgmp_location_state%":"PA","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Scranton, PA, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"41.410314","%_wpgmp_metabox_longitude%":"-75.661099","%rank_math_internal_links_processed%":"1"}},"id":2776,"infowindow_disable":false},{"source":"post","title":"Construction Laborer","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Construction Laborer\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Turner Staffing Group \u2013 Construction Laborer Do you love the dirt world? Do you think differently? Are you ready to&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/construction-laborer\/\" name=\"Construction Laborer\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Turner Staffing Group \u2013 Construction Laborer Do you love the dirt world? Do you think differently? Are you ready to&hellip;","address":"Philadelphia, PA, USA","location":{"lat":"39.9525839","city":"Philadelphia","state":"PA","country":"United States","lng":"-75.1652215","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/construction-laborer\/","zoom":19,"extra_fields":{"post_excerpt":"Turner Staffing Group \u2013 Construction Laborer Do you love the dirt world? Do you think differently? Are you ready to&hellip;","post_content":"<p><strong><u>Turner Staffing Group \u2013 Construction Laborer<\/u><\/strong><\/p>\n<p>Do you love the dirt world? 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 civil construction 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 Construction Laborers for our fast-growing, forward thinking client based in the Philadelphia area.<br><\/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 construction firms 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 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>Performing tasks as directed by management&nbsp;in a civil construction environment<\/li><li>Assist in basic maintenance and upkeep of equipment<\/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 is a plus<\/li><li>Preferred to have OSHA training<\/li><\/ul>","post_title":"Construction Laborer","post_link":"https:\/\/turnerstaffing.com\/position\/construction-laborer\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Associate","%location_country%":"United States","%location_city%":"Philadelphia","%location_state_id%":"PA","%location_state_name%":"Pennsylvania","%location_city_state%":"Philadelphia, PA","%education%":"Unspecified","%department%":"","%description%":"<p><strong><u>Turner Staffing Group \u2013 Construction Laborer<\/u><\/strong><\/p>\n<p>Do you love the dirt world? 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 civil construction 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 Construction Laborers for our fast-growing, forward thinking client based in the Philadelphia area.<br><\/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 construction firms 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 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>Performing tasks as directed by management&nbsp;in a civil construction environment<\/li><li>Assist in basic maintenance and upkeep of equipment<\/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 is a plus<\/li><li>Preferred to have OSHA training<\/li><\/ul>","%category%":"Operations","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/27b18bea9dd8-construction-laborer","%breezy_id%":"27b18bea9dd8","%breezy_friendly_id%":"27b18bea9dd8-construction-laborer","%breezy_created_date%":"2025-04-03T18:00:18.513Z","%breezy_updated_date%":"2025-11-14T20:40:27.762Z","%_wpgmp_location_city%":"Philadelphia","%_wpgmp_location_state%":"PA","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Philadelphia, PA, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"39.9525839","%_wpgmp_metabox_longitude%":"-75.1652215","%rank_math_internal_links_processed%":"1"}},"id":2773,"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 Staffing 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 Staffing Group \u2013 Heavy Equipment Operator Do you love mining? Do you think differently? Are you ready to define&hellip;","address":"Bullhead City, AZ, USA","location":{"lat":"35.1359386","city":"Bullhead City","state":"AZ","country":"United States","lng":"-114.5285981","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/blade-operator\/","zoom":19,"extra_fields":{"post_excerpt":"Turner Staffing 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 Staffing 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 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 mining Blade Operator for our fast-growing, forward thinking mining services company at our project in Bullhead City, AZ.<\/p>\n<p>Turner Staffing 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>","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%":"Bullhead City","%location_state_id%":"AZ","%location_state_name%":"Arizona","%location_city_state%":"Bullhead City, AZ","%education%":"Unspecified","%department%":"Operations","%description%":"<p><strong><u>Turner Staffing 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 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 mining Blade Operator for our fast-growing, forward thinking mining services company at our project in Bullhead City, AZ.<\/p>\n<p>Turner Staffing 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>","%category%":"Operations","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/f35c13e4b30b-blade-operator","%breezy_id%":"f35c13e4b30b","%breezy_friendly_id%":"f35c13e4b30b-blade-operator","%breezy_created_date%":"2025-09-17T15:09:32.324Z","%breezy_updated_date%":"2026-01-14T19:04:23.363Z","%_wpgmp_location_city%":"Bullhead City","%_wpgmp_location_state%":"AZ","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Bullhead City, AZ, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"35.1359386","%_wpgmp_metabox_longitude%":"-114.5285981","%rank_math_internal_links_processed%":"1"}},"id":2767,"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 Staffing Group \u2013 Dozer Operator Do you love the dirt world? Do you think differently? Are you ready to&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 Staffing Group \u2013 Dozer Operator Do you love the dirt world? Do you think differently? Are you ready to&hellip;","address":"Philadelphia, PA, USA","location":{"lat":"39.9525839","city":"Philadelphia","state":"PA","country":"United States","lng":"-75.1652215","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/dozer-operator-6\/","zoom":19,"extra_fields":{"post_excerpt":"Turner Staffing Group \u2013 Dozer Operator Do you love the dirt world? Do you think differently? Are you ready to&hellip;","post_content":"<p><strong><u>Turner Staffing Group \u2013 Dozer Operator<\/u><\/strong><\/p>\n<p>Do you love the dirt world? 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 civil construction&nbsp;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 Dozer Operators for our fast-growing, forward thinking client based&nbsp;in the Philadelphia area.<br><\/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 construction firms&nbsp;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 excavators in a civil construction&nbsp;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 OSHA training<\/li><\/ul>","post_title":"Dozer Operator","post_link":"https:\/\/turnerstaffing.com\/position\/dozer-operator-6\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Mid Level","%location_country%":"United States","%location_city%":"Philadelphia","%location_state_id%":"PA","%location_state_name%":"Pennsylvania","%location_city_state%":"Philadelphia, PA","%education%":"Unspecified","%department%":"","%description%":"<p><strong><u>Turner Staffing Group \u2013 Dozer Operator<\/u><\/strong><\/p>\n<p>Do you love the dirt world? 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 civil construction&nbsp;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 Dozer Operators for our fast-growing, forward thinking client based&nbsp;in the Philadelphia area.<br><\/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 construction firms&nbsp;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 excavators in a civil construction&nbsp;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 OSHA training<\/li><\/ul>","%category%":"Operations","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/6daac192b598-dozer-operator","%breezy_id%":"6daac192b598","%breezy_friendly_id%":"6daac192b598-dozer-operator","%breezy_created_date%":"2025-04-03T16:25:53.355Z","%breezy_updated_date%":"2025-11-14T20:40:35.603Z","%_wpgmp_location_city%":"Philadelphia","%_wpgmp_location_state%":"PA","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Philadelphia, PA, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"39.9525839","%_wpgmp_metabox_longitude%":"-75.1652215","%rank_math_internal_links_processed%":"1"}},"id":2764,"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 Staffing Group \u2013 Haul Truck Driver Do you love the dirt world? Do you think differently? Are you ready&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/haul-truck-driver-5\/\" name=\"Haul Truck Driver\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Turner Staffing Group \u2013 Haul Truck Driver Do you love the dirt world? Do you think differently? Are you ready&hellip;","address":"Bowmansville, PA, USA","location":{"lat":"40.1967609","city":"Bowmansville","state":"PA","country":"United States","lng":"-76.0174416","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/haul-truck-driver-5\/","zoom":19,"extra_fields":{"post_excerpt":"Turner Staffing Group \u2013 Haul Truck Driver Do you love the dirt world? Do you think differently? Are you ready&hellip;","post_content":"<p><strong><u>Turner Staffing Group \u2013 Haul Truck Driver<\/u><\/strong><\/p>\n<p>Do you love the dirt world? 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 civil construction 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 Haul Truck Drivers for our fast-growing, forward thinking client based in the Philadelphia area.<br><\/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 construction firms 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 haul trucks in a civil construction 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 OSHA training<\/li><\/ul>","post_title":"Haul Truck Driver","post_link":"https:\/\/turnerstaffing.com\/position\/haul-truck-driver-5\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Associate","%location_country%":"United States","%location_city%":"Bowmansville","%location_state_id%":"PA","%location_state_name%":"Pennsylvania","%location_city_state%":"Bowmansville, PA","%education%":"Unspecified","%department%":"","%description%":"<p><strong><u>Turner Staffing Group \u2013 Haul Truck Driver<\/u><\/strong><\/p>\n<p>Do you love the dirt world? 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 civil construction 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 Haul Truck Drivers for our fast-growing, forward thinking client based in the Philadelphia area.<br><\/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 construction firms 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 haul trucks in a civil construction 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 OSHA training<\/li><\/ul>","%category%":"Operations","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/9dca286535b8-haul-truck-driver","%breezy_id%":"9dca286535b8","%breezy_friendly_id%":"9dca286535b8-haul-truck-driver","%breezy_created_date%":"2025-04-03T17:55:01.519Z","%breezy_updated_date%":"2025-10-20T17:43:10.128Z","%_wpgmp_location_city%":"Bowmansville","%_wpgmp_location_state%":"PA","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Bowmansville, PA, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"40.1967609","%_wpgmp_metabox_longitude%":"-76.0174416","%rank_math_internal_links_processed%":"1"}},"id":2765,"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 Staffing Group \u2013 Excavator Operator Do you love the dirt world? Do you think differently? Are you ready to&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/excavator-operator-5\/\" name=\"Excavator Operator\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Turner Staffing Group \u2013 Excavator Operator Do you love the dirt world? Do you think differently? Are you ready to&hellip;","address":"Philadelphia, PA, USA","location":{"lat":"39.9525839","city":"Philadelphia","state":"PA","country":"United States","lng":"-75.1652215","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/excavator-operator-5\/","zoom":19,"extra_fields":{"post_excerpt":"Turner Staffing Group \u2013 Excavator Operator Do you love the dirt world? Do you think differently? Are you ready to&hellip;","post_content":"<p><strong><u>Turner Staffing Group \u2013 Excavator Operator<\/u><\/strong><\/p>\n<p>Do you love the dirt world? 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 civil construction&nbsp;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 Excavator Operators for our fast-growing, forward thinking client based in the Philadelphia area.<br><\/p>\n\n<p><strong>You<\/strong><\/p>\n<p>You want to work for a services company that is rapidly changing the way the largest construction firms 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 excavators in a civil construction 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 OSHA training<\/li><\/ul>","post_title":"Excavator Operator","post_link":"https:\/\/turnerstaffing.com\/position\/excavator-operator-5\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Mid Level","%location_country%":"United States","%location_city%":"Philadelphia","%location_state_id%":"PA","%location_state_name%":"Pennsylvania","%location_city_state%":"Philadelphia, PA","%education%":"Unspecified","%department%":"","%description%":"<p><strong><u>Turner Staffing Group \u2013 Excavator Operator<\/u><\/strong><\/p>\n<p>Do you love the dirt world? 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 civil construction&nbsp;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 Excavator Operators for our fast-growing, forward thinking client based in the Philadelphia area.<br><\/p>\n\n<p><strong>You<\/strong><\/p>\n<p>You want to work for a services company that is rapidly changing the way the largest construction firms 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 excavators in a civil construction 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 OSHA training<\/li><\/ul>","%category%":"Operations","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/3ad5c75065c7-excavator-operator","%breezy_id%":"3ad5c75065c7","%breezy_friendly_id%":"3ad5c75065c7-excavator-operator","%breezy_created_date%":"2025-04-03T16:23:33.387Z","%breezy_updated_date%":"2025-11-14T20:40:52.004Z","%_wpgmp_location_city%":"Philadelphia","%_wpgmp_location_state%":"PA","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Philadelphia, PA, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"39.9525839","%_wpgmp_metabox_longitude%":"-75.1652215","%rank_math_internal_links_processed%":"1"}},"id":2763,"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    Job Summary: Turner Staffing Group is seeking a skilled and experienced Dozer Operator for a reputable mining company located in&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/dozer-operator-5\/\" name=\"Dozer Operator\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Job Summary: Turner Staffing Group is seeking a skilled and experienced Dozer Operator for a reputable mining company located in&hellip;","address":"Bowmansville, PA, USA","location":{"lat":"40.1967609","city":"Bowmansville","state":"PA","country":"United States","lng":"-76.0174416","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/dozer-operator-5\/","zoom":19,"extra_fields":{"post_excerpt":"Job Summary: Turner Staffing Group is seeking a skilled and experienced Dozer Operator for a reputable mining company located in&hellip;","post_content":"<h3><strong>Job Summary:<\/strong><\/h3>\n<p>Turner Staffing Group is seeking a skilled and experienced <strong>Dozer Operator<\/strong> for a reputable mining company located in Pennsylvania. The Dozer Operator will be responsible for operating heavy dozers and related equipment to support mining operations in a surface mining setting. The ideal candidate will have experience in heavy equipment operation, particularly dozers, and be able to work efficiently in an outdoor, physically demanding environment.<\/p><h3><strong>Key Responsibilities:<\/strong><\/h3>\n<ul><li><strong>Operate Dozers:<\/strong> Safely operate various dozers (D9, D10, D11, or similar) to perform tasks including grading, pushing, leveling, and clearing materials in a surface mining operation.<\/li><li><strong>Material Handling:<\/strong> Transport materials to designated areas, ensuring that the equipment is operated in compliance with project plans and specifications.<\/li><li><strong>Worksite Safety:<\/strong> Follow all safety protocols and company guidelines to ensure a safe working environment for yourself and others. Adhere to OSHA and MSHA regulations.<\/li><li><strong>Equipment Care:<\/strong> Perform routine maintenance checks on dozers and other heavy equipment, including checking fluid levels, tire pressure, and general machine function. Report any mechanical issues or concerns to the equipment maintenance team.<\/li><li><strong>Collaboration:<\/strong> Work closely with other operators, ground crew, and supervisors to ensure smooth operations and efficient progress of mining activities.<\/li><li><strong>Weather and Terrain Adaptability:<\/strong> Able to work in various weather conditions and on rough, uneven terrain typical of surface mining operations.<\/li><li><strong>Documentation:<\/strong> Maintain accurate records of work performed, including daily logs and any issues or maintenance required on equipment.<\/li><\/ul><p><\/p><h3><strong>Qualifications:<\/strong><\/h3>\n<ul><li><strong>Experience:<\/strong> Minimum of 2-3 years operating dozers in a mining, construction, or similar heavy equipment environment.<\/li><li><strong>Skills:<\/strong><ul><li>Proficient in operating dozers and similar heavy machinery in a mining environment.<\/li><li>Ability to perform routine maintenance and troubleshooting of heavy equipment.<\/li><li>Strong knowledge of safety standards and best practices in a mining or construction setting.<\/li><\/ul><\/li><li><strong>Physical Requirements:<\/strong> Ability to perform physically demanding tasks, including operating heavy machinery for extended periods and working in harsh weather conditions.<\/li><\/ul>","post_title":"Dozer Operator","post_link":"https:\/\/turnerstaffing.com\/position\/dozer-operator-5\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"","%location_country%":"United States","%location_city%":"Bowmansville","%location_state_id%":"PA","%location_state_name%":"Pennsylvania","%location_city_state%":"Bowmansville, PA","%education%":"","%department%":"","%description%":"<h3><strong>Job Summary:<\/strong><\/h3>\n<p>Turner Staffing Group is seeking a skilled and experienced <strong>Dozer Operator<\/strong> for a reputable mining company located in Pennsylvania. The Dozer Operator will be responsible for operating heavy dozers and related equipment to support mining operations in a surface mining setting. The ideal candidate will have experience in heavy equipment operation, particularly dozers, and be able to work efficiently in an outdoor, physically demanding environment.<\/p><h3><strong>Key Responsibilities:<\/strong><\/h3>\n<ul><li><strong>Operate Dozers:<\/strong> Safely operate various dozers (D9, D10, D11, or similar) to perform tasks including grading, pushing, leveling, and clearing materials in a surface mining operation.<\/li><li><strong>Material Handling:<\/strong> Transport materials to designated areas, ensuring that the equipment is operated in compliance with project plans and specifications.<\/li><li><strong>Worksite Safety:<\/strong> Follow all safety protocols and company guidelines to ensure a safe working environment for yourself and others. Adhere to OSHA and MSHA regulations.<\/li><li><strong>Equipment Care:<\/strong> Perform routine maintenance checks on dozers and other heavy equipment, including checking fluid levels, tire pressure, and general machine function. Report any mechanical issues or concerns to the equipment maintenance team.<\/li><li><strong>Collaboration:<\/strong> Work closely with other operators, ground crew, and supervisors to ensure smooth operations and efficient progress of mining activities.<\/li><li><strong>Weather and Terrain Adaptability:<\/strong> Able to work in various weather conditions and on rough, uneven terrain typical of surface mining operations.<\/li><li><strong>Documentation:<\/strong> Maintain accurate records of work performed, including daily logs and any issues or maintenance required on equipment.<\/li><\/ul><p><\/p><h3><strong>Qualifications:<\/strong><\/h3>\n<ul><li><strong>Experience:<\/strong> Minimum of 2-3 years operating dozers in a mining, construction, or similar heavy equipment environment.<\/li><li><strong>Skills:<\/strong><ul><li>Proficient in operating dozers and similar heavy machinery in a mining environment.<\/li><li>Ability to perform routine maintenance and troubleshooting of heavy equipment.<\/li><li>Strong knowledge of safety standards and best practices in a mining or construction setting.<\/li><\/ul><\/li><li><strong>Physical Requirements:<\/strong> Ability to perform physically demanding tasks, including operating heavy machinery for extended periods and working in harsh weather conditions.<\/li><\/ul>","%category%":"","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/ed543c58aa22-dozer-operator","%breezy_id%":"ed543c58aa22","%breezy_friendly_id%":"ed543c58aa22-dozer-operator","%breezy_created_date%":"2024-11-11T21:54:27.413Z","%breezy_updated_date%":"2026-01-14T19:07:47.965Z","%_wpgmp_location_city%":"Bowmansville","%_wpgmp_location_state%":"PA","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Bowmansville, PA, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"40.1967609","%_wpgmp_metabox_longitude%":"-76.0174416","%rank_math_internal_links_processed%":"1"}},"id":2762,"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    About Us:Turner Staffing Group is a leading staffing agency dedicated to connecting skilled professionals with rewarding opportunities. We are proud&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/excavator-operator-4\/\" name=\"Excavator Operator\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"About Us:Turner Staffing Group is a leading staffing agency dedicated to connecting skilled professionals with rewarding opportunities. We are proud&hellip;","address":"Bowmansville, PA, USA","location":{"lat":"40.1967609","city":"Bowmansville","state":"PA","country":"United States","lng":"-76.0174416","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/excavator-operator-4\/","zoom":19,"extra_fields":{"post_excerpt":"About Us:Turner Staffing Group is a leading staffing agency dedicated to connecting skilled professionals with rewarding opportunities. We are proud&hellip;","post_content":"<p><strong>About Us:<\/strong><br>Turner 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 Bowmansville, Pennsylvania. 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 Bowmansville, Pennsylvania. 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>&nbsp;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>&nbsp;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>&nbsp;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>&nbsp;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>&nbsp;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>&nbsp;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-4\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"","%location_country%":"United States","%location_city%":"Bowmansville","%location_state_id%":"PA","%location_state_name%":"Pennsylvania","%location_city_state%":"Bowmansville, PA","%education%":"","%department%":"","%description%":"<p><strong>About Us:<\/strong><br>Turner 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 Bowmansville, Pennsylvania. 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 Bowmansville, Pennsylvania. 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>&nbsp;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>&nbsp;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>&nbsp;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>&nbsp;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>&nbsp;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>&nbsp;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%":"","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/557ad6ff5763-excavator-operator","%breezy_id%":"557ad6ff5763","%breezy_friendly_id%":"557ad6ff5763-excavator-operator","%breezy_created_date%":"2024-11-11T21:22:05.636Z","%breezy_updated_date%":"2026-01-14T19:10:10.663Z","%_wpgmp_location_city%":"Bowmansville","%_wpgmp_location_state%":"PA","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Bowmansville, PA, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"40.1967609","%_wpgmp_metabox_longitude%":"-76.0174416","%rank_math_internal_links_processed%":"1"}},"id":2760,"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    About Us:Turner Staffing Group, in collaboration with our esteemed mining partner in Bowmansville, Pennsylvania, is actively seeking experienced Heavy Equipment&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/heavy-equipment-operator-9\/\" name=\"Heavy Equipment Operator\" 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 Bowmansville, Pennsylvania, is actively seeking experienced Heavy Equipment&hellip;","address":"Bowmansville, PA, USA","location":{"lat":"40.1967609","city":"Bowmansville","state":"PA","country":"United States","lng":"-76.0174416","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/heavy-equipment-operator-9\/","zoom":19,"extra_fields":{"post_excerpt":"About Us:Turner Staffing Group, in collaboration with our esteemed mining partner in Bowmansville, Pennsylvania, is actively seeking experienced Heavy Equipment&hellip;","post_content":"<p><strong>About Us:<\/strong><br>Turner Staffing Group, in collaboration with our esteemed mining partner in Bowmansville, Pennsylvania, 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><br>We 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-9\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"","%location_country%":"United States","%location_city%":"Bowmansville","%location_state_id%":"PA","%location_state_name%":"Pennsylvania","%location_city_state%":"Bowmansville, PA","%education%":"","%department%":"","%description%":"<p><strong>About Us:<\/strong><br>Turner Staffing Group, in collaboration with our esteemed mining partner in Bowmansville, Pennsylvania, 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><br>We 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%":"","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/3cc09490897f-heavy-equipment-operator","%breezy_id%":"3cc09490897f","%breezy_friendly_id%":"3cc09490897f-heavy-equipment-operator","%breezy_created_date%":"2024-11-11T21:32:36.264Z","%breezy_updated_date%":"2026-01-14T19:16:55.817Z","%_wpgmp_location_city%":"Bowmansville","%_wpgmp_location_state%":"PA","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Bowmansville, PA, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"40.1967609","%_wpgmp_metabox_longitude%":"-76.0174416","%rank_math_internal_links_processed%":"1"}},"id":2761,"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    Electrical Maintenance Technician &ndash; Draglines &amp; Electric Shovels Schedule: DuPont Schedule &ndash; 12-hour rotating days\/nights (6:30 AM&ndash;6:30 PM), 7 days&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":"Electrical Maintenance Technician &ndash; Draglines &amp; Electric Shovels Schedule: DuPont Schedule &ndash; 12-hour rotating days\/nights (6:30 AM&ndash;6:30 PM), 7 days&hellip;","address":"Wright, WY, USA","location":{"lat":"43.7518832","city":"Wright","state":"WY","country":"United States","lng":"-105.4913345","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/electrician-2\/","zoom":19,"extra_fields":{"post_excerpt":"Electrical Maintenance Technician &ndash; Draglines &amp; Electric Shovels Schedule: DuPont Schedule &ndash; 12-hour rotating days\/nights (6:30 AM&ndash;6:30 PM), 7 days&hellip;","post_content":"<p><strong>Electrical Maintenance Technician &ndash; Draglines &amp; Electric Shovels<\/strong><\/p><p><strong>Schedule:<\/strong> DuPont Schedule &ndash; 12-hour rotating days\/nights (6:30 AM&ndash;6:30 PM), 7 days on \/ 7 days off<br \/><strong>Employment Type:<\/strong> Full-Time, Temporary with possibility of converting to permanent position after 6 months.<\/p><p>Turner Staffing Group is seeking <strong>Electrical Maintenance Technicians<\/strong> to support operations on draglines and electric shovels at the North Antelope Rochelle Mine near Wright, Wyoming. This role is ideal for professionals with strong DC motor\/generator troubleshooting skills who thrive in heavy-industrial or mining environments.<\/p><strong>Key Responsibilities<\/strong> <ul><li><p>Perform preventive and breakdown maintenance on draglines, electric shovels, and other fixed\/mobile plant equipment in an open-cut mining environment.<\/p><\/li><li><p>Visibly support and champion our client&rsquo;s mission, values, and &ldquo;Safety as a Way of Life&rdquo; culture.<\/p><\/li><li><p>Inspect work areas and equipment for hazards, damage, and defects.<\/p><\/li><li><p>Review drawings or specifications to determine work methods and sequences.<\/p><\/li><li><p>Diagnose faults, breakdowns, and electrical issues.<\/p><\/li><li><p>Estimate time and materials needed, raise material orders, and complete repairs or component changeouts as required.<\/p><\/li><li><p>Clean and maintain tools, equipment, and work areas.<\/p><\/li><li><p>Train or mentor apprentices or other personnel as needed.<\/p><\/li><li><p>Ensure compliance with safety, environmental, and statutory requirements.<\/p><\/li><li><p>Perform other duties as assigned.<\/p><\/li><\/ul><strong>About You<\/strong> <ul><li><p>At least 3 years of electrical maintenance experience in a heavy-industrial setting (mining preferred, but steel\/paper mills are also valuable backgrounds).<\/p><\/li><li><p><strong>Strong DC motor\/generator troubleshooting and repair experience is required.<\/strong><\/p><\/li><li><p><span style=\"color:#000000;font-size:15px;font-family:Arial, Helvetica, sans-serif\">480-600V experience<\/span><\/p><\/li><li><p><span style=\"color:#000000;font-size:15px;font-family:Arial, Helvetica, sans-serif\">PLC experience is highly preferred<\/span><\/p><\/li><li><p>Willingness to obtain <strong>MSHA certification<\/strong> and a <strong>Wyoming Mining Electrical Card<\/strong> during onboarding (if not currently held).<\/p><\/li><li><p>Ability to solve problems independently and troubleshoot issues in pit areas.<\/p><\/li><li><p>Comfortable working in all weather conditions, at varying times of day, including rotating shifts, weekends, and overtime.<\/p><\/li><li><p>High School Diploma or GED required.<\/p><\/li><\/ul><strong>Physical Requirements<\/strong> <ul><li><p>Ability to stand or sit for extended periods (up to 4 hours).<\/p><\/li><li><p>Comfortable climbing stairs, ladders, and equipment; working from elevated positions.<\/p><\/li><li><p>Capable of frequent lifting\/carrying (10&ndash;50 lbs) without mechanical assistance.<\/p><\/li><li><p>Ability to perform repetitive motions, maintain rapid reflexes, and demonstrate good hand-eye coordination.<\/p><\/li><li><p>Must wear required PPE (protective footwear, hearing\/eye protection, etc.) and work in varying light, noise, and weather conditions.<\/p><\/li><\/ul><strong>Work Schedule &amp; Lifestyle<\/strong> <ul><li><p>DuPont schedule: 12-hour rotating shifts, 7 days on \/ 7 days off.<\/p><\/li><li><p>May require work on weekends, holidays, or alternate shifts as business needs demand.<\/p><\/li><\/ul><strong>Requirements<\/strong> <ul><li><p>Must be <strong>authorized to work in the U.S.<\/strong> (no work visa sponsorship available).<\/p><\/li><li><p>Successful candidates must pass pre-employment screenings and meet all safety standards.<\/p><\/li><\/ul><p><strong>Join Turner Staffing Group and make an impact by supporting one of the world&rsquo;s leading surface coal operations. Apply today to bring your electrical expertise to an exciting, high-performing mining environment!<\/strong><\/p>","post_title":"Electrician","post_link":"https:\/\/turnerstaffing.com\/position\/electrician-2\/","post_featured_image":"","post_categories":"","post_tags":"","%location_country%":"United States","%location_city%":"Wright","%location_state_id%":"WY","%location_city_state%":"Wright, WY","%description%":"<p><strong>Electrical Maintenance Technician &ndash; Draglines &amp; Electric Shovels<\/strong><\/p><p><strong>Schedule:<\/strong> DuPont Schedule &ndash; 12-hour rotating days\/nights (6:30 AM&ndash;6:30 PM), 7 days on \/ 7 days off<br \/><strong>Employment Type:<\/strong> Full-Time, Temporary with possibility of converting to permanent position after 6 months.<\/p><p>Turner Staffing Group is seeking <strong>Electrical Maintenance Technicians<\/strong> to support operations on draglines and electric shovels at the North Antelope Rochelle Mine near Wright, Wyoming. This role is ideal for professionals with strong DC motor\/generator troubleshooting skills who thrive in heavy-industrial or mining environments.<\/p><strong>Key Responsibilities<\/strong> <ul><li><p>Perform preventive and breakdown maintenance on draglines, electric shovels, and other fixed\/mobile plant equipment in an open-cut mining environment.<\/p><\/li><li><p>Visibly support and champion our client&rsquo;s mission, values, and &ldquo;Safety as a Way of Life&rdquo; culture.<\/p><\/li><li><p>Inspect work areas and equipment for hazards, damage, and defects.<\/p><\/li><li><p>Review drawings or specifications to determine work methods and sequences.<\/p><\/li><li><p>Diagnose faults, breakdowns, and electrical issues.<\/p><\/li><li><p>Estimate time and materials needed, raise material orders, and complete repairs or component changeouts as required.<\/p><\/li><li><p>Clean and maintain tools, equipment, and work areas.<\/p><\/li><li><p>Train or mentor apprentices or other personnel as needed.<\/p><\/li><li><p>Ensure compliance with safety, environmental, and statutory requirements.<\/p><\/li><li><p>Perform other duties as assigned.<\/p><\/li><\/ul><strong>About You<\/strong> <ul><li><p>At least 3 years of electrical maintenance experience in a heavy-industrial setting (mining preferred, but steel\/paper mills are also valuable backgrounds).<\/p><\/li><li><p><strong>Strong DC motor\/generator troubleshooting and repair experience is required.<\/strong><\/p><\/li><li><p><span style=\"color:#000000;font-size:15px;font-family:Arial, Helvetica, sans-serif;\">480-600V experience<\/span><\/p><\/li><li><p><span style=\"color:#000000;font-size:15px;font-family:Arial, Helvetica, sans-serif;\">PLC experience is highly preferred<\/span><\/p><\/li><li><p>Willingness to obtain <strong>MSHA certification<\/strong> and a <strong>Wyoming Mining Electrical Card<\/strong> during onboarding (if not currently held).<\/p><\/li><li><p>Ability to solve problems independently and troubleshoot issues in pit areas.<\/p><\/li><li><p>Comfortable working in all weather conditions, at varying times of day, including rotating shifts, weekends, and overtime.<\/p><\/li><li><p>High School Diploma or GED required.<\/p><\/li><\/ul><strong>Physical Requirements<\/strong> <ul><li><p>Ability to stand or sit for extended periods (up to 4 hours).<\/p><\/li><li><p>Comfortable climbing stairs, ladders, and equipment; working from elevated positions.<\/p><\/li><li><p>Capable of frequent lifting\/carrying (10&ndash;50 lbs) without mechanical assistance.<\/p><\/li><li><p>Ability to perform repetitive motions, maintain rapid reflexes, and demonstrate good hand-eye coordination.<\/p><\/li><li><p>Must wear required PPE (protective footwear, hearing\/eye protection, etc.) and work in varying light, noise, and weather conditions.<\/p><\/li><\/ul><strong>Work Schedule &amp; Lifestyle<\/strong> <ul><li><p>DuPont schedule: 12-hour rotating shifts, 7 days on \/ 7 days off.<\/p><\/li><li><p>May require work on weekends, holidays, or alternate shifts as business needs demand.<\/p><\/li><\/ul><strong>Requirements<\/strong> <ul><li><p>Must be <strong>authorized to work in the U.S.<\/strong> (no work visa sponsorship available).<\/p><\/li><li><p>Successful candidates must pass pre-employment screenings and meet all safety standards.<\/p><\/li><\/ul><p><strong>Join Turner Staffing Group and make an impact by supporting one of the world&rsquo;s leading surface coal operations. Apply today to bring your electrical expertise to an exciting, high-performing mining environment!<\/strong><\/p>","%application_url%":"https:\/\/jobs.crelate.com\/portal\/turnerstaffinggroup\/job\/rhsh8o43riyojxdrogg9ixa7hw","%crelate_id%":"rhsh8o43riyojxdrogg9ixa7hw","%crelate_created_date%":"2025-09-16T16:10:40.74Z","%crelate_updated_date%":"2025-12-14T15:04:28.46Z","%_wpgmp_location_city%":"Wright","%_wpgmp_location_state%":"WY","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Wright, WY, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"43.7518832","%_wpgmp_metabox_longitude%":"-105.4913345","%rank_math_internal_links_processed%":"1"}},"id":2759,"infowindow_disable":false},{"source":"post","title":"Mining Electrician","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Mining Electrician\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    This role will carry out preventive and breakdown maintenance to fixed and mobile plant in an open cut environments. Duties&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/mining-electrician-2\/\" name=\"Mining Electrician\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"This role will carry out preventive and breakdown maintenance to fixed and mobile plant in an open cut environments. Duties&hellip;","address":"Gillette, WY, USA","location":{"lat":"44.2931097","city":"Gillette","state":"WY","country":"United States","lng":"-105.494199","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/mining-electrician-2\/","zoom":19,"extra_fields":{"post_excerpt":"This role will carry out preventive and breakdown maintenance to fixed and mobile plant in an open cut environments. Duties&hellip;","post_content":"<p>This role will carry out preventive and breakdown maintenance to fixed and mobile plant in an open cut environments.<\/p>\n<p><\/p>\n<p>Duties will include:<\/p>\n<ul><li>Visibly support and champion our client's Mission and Values<\/li><li>Act in accordance with and adhere to Safety as a Way of Life Management System<\/li><\/ul>\n<ul><li>Inspect work area and plant for hazards, damage and defects<\/li><li>Examine drawings or specifications to determine work methods, sequence of activities or manufacture of components<\/li><li>Diagnose faults or breakdowns<\/li><li>Estimate time and materials required to complete jobs<\/li><li>Raise orders for materials<\/li><li>Undertake repairs or component changeouts as required<\/li><li>Clean and maintain tools and work area<\/li><li>Train other personnel or apprentices (if required)<\/li><li>Ensure activities comply with safety, environmental and statutory requirements<\/li><li>Other duties as assigned by the company<\/li><\/ul>\n<p><\/p>\n<p><strong>The Lifestyle:<\/strong><\/p>\n<p>This position may require the necessity to work weekends, holidays, or another shift as deemed necessary.&nbsp;&nbsp;&nbsp;<br><\/p>\n<p><\/p>\n<p><strong>About you:<\/strong><\/p>\n<ul><li>Three years\u2019 experience performing electrical maintenance work in a heavy industrial environment or mine site is preferred.<\/li><li>Ability to solve problems and troubleshoot situations arising in the pit area as needed.<\/li><li>Ability to work in all types of weather conditions and at different times of day.<\/li><li>Ability to work a flexible schedule as required by business need.<\/li><li>Ability to work rotating shifts, weekends and overtime when required.<\/li><li>High School Degree or GED Equivalent required<\/li><\/ul>\n<p><\/p>\n<p><strong>Physical Requirements - Surface:<\/strong><\/p>\n<ul><li>Must have the ability to stand for up to 4 hours per shift<\/li><li>Must have the ability to be seated for up to 4 hours to operate equipment or vehicles<\/li><li>Must have the ability to work from elevated positions, walk\/climb up and down stairs\/steps and climb on and off equipment and ladders<\/li><li>Must have the ability to wear required protective footwear, hearing and eye protection, and other personal protective equipment as required by Company and MSHA<\/li><li>Must have the ability to perform repetitive hand and wrist motions (push, pull, twist, handle), and have rapid reflex movements of the arms and legs and good hand to eye coordination<\/li><li>Must have the ability to lift\/raise 10 - 50 lbs. without mechanical assistance frequently during the course of work shift&nbsp;<\/li><li>Must have the ability to work in extreme conditions, including but not limited to changing weather conditions, dust, mud, varying levels of noise from low to high, varying degrees of light and dark, in and around artificial light and in a confined work area<\/li><li>The job requires that you be able to work various shifts (required shifts include days, evenings and nights with rotating schedules, weekends and holidays&nbsp;&nbsp;&nbsp;<\/li><\/ul>","post_title":"Mining Electrician","post_link":"https:\/\/turnerstaffing.com\/position\/mining-electrician-2\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Mid Level","%location_country%":"United States","%location_city%":"Gillette","%location_state_id%":"WY","%location_state_name%":"Wyoming","%location_city_state%":"Gillette, WY","%education%":"High School or equivalent","%department%":"","%description%":"<p>This role will carry out preventive and breakdown maintenance to fixed and mobile plant in an open cut environments.<\/p>\n<p><\/p>\n<p>Duties will include:<\/p>\n<ul><li>Visibly support and champion our client's Mission and Values<\/li><li>Act in accordance with and adhere to Safety as a Way of Life Management System<\/li><\/ul>\n<ul><li>Inspect work area and plant for hazards, damage and defects<\/li><li>Examine drawings or specifications to determine work methods, sequence of activities or manufacture of components<\/li><li>Diagnose faults or breakdowns<\/li><li>Estimate time and materials required to complete jobs<\/li><li>Raise orders for materials<\/li><li>Undertake repairs or component changeouts as required<\/li><li>Clean and maintain tools and work area<\/li><li>Train other personnel or apprentices (if required)<\/li><li>Ensure activities comply with safety, environmental and statutory requirements<\/li><li>Other duties as assigned by the company<\/li><\/ul>\n<p><\/p>\n<p><strong>The Lifestyle:<\/strong><\/p>\n<p>This position may require the necessity to work weekends, holidays, or another shift as deemed necessary.&nbsp;&nbsp;&nbsp;<br><\/p>\n<p><\/p>\n<p><strong>About you:<\/strong><\/p>\n<ul><li>Three years\u2019 experience performing electrical maintenance work in a heavy industrial environment or mine site is preferred.<\/li><li>Ability to solve problems and troubleshoot situations arising in the pit area as needed.<\/li><li>Ability to work in all types of weather conditions and at different times of day.<\/li><li>Ability to work a flexible schedule as required by business need.<\/li><li>Ability to work rotating shifts, weekends and overtime when required.<\/li><li>High School Degree or GED Equivalent required<\/li><\/ul>\n<p><\/p>\n<p><strong>Physical Requirements - Surface:<\/strong><\/p>\n<ul><li>Must have the ability to stand for up to 4 hours per shift<\/li><li>Must have the ability to be seated for up to 4 hours to operate equipment or vehicles<\/li><li>Must have the ability to work from elevated positions, walk\/climb up and down stairs\/steps and climb on and off equipment and ladders<\/li><li>Must have the ability to wear required protective footwear, hearing and eye protection, and other personal protective equipment as required by Company and MSHA<\/li><li>Must have the ability to perform repetitive hand and wrist motions (push, pull, twist, handle), and have rapid reflex movements of the arms and legs and good hand to eye coordination<\/li><li>Must have the ability to lift\/raise 10 - 50 lbs. without mechanical assistance frequently during the course of work shift&nbsp;<\/li><li>Must have the ability to work in extreme conditions, including but not limited to changing weather conditions, dust, mud, varying levels of noise from low to high, varying degrees of light and dark, in and around artificial light and in a confined work area<\/li><li>The job requires that you be able to work various shifts (required shifts include days, evenings and nights with rotating schedules, weekends and holidays&nbsp;&nbsp;&nbsp;<\/li><\/ul>","%category%":"Operations","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/20b1e577c15e-mining-electrician","%breezy_id%":"20b1e577c15e","%breezy_friendly_id%":"20b1e577c15e-mining-electrician","%breezy_created_date%":"2025-09-16T15:45:41.918Z","%breezy_updated_date%":"2026-01-14T19:22:13.381Z","%_wpgmp_location_city%":"Gillette","%_wpgmp_location_state%":"WY","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Gillette, WY, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"44.2931097","%_wpgmp_metabox_longitude%":"-105.494199","%rank_math_internal_links_processed%":"1"}},"id":2756,"infowindow_disable":false},{"source":"post","title":"Mining Electrician- Traveling","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Mining Electrician- Traveling\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    This role will be performed near Wright, WY and&nbsp;will carry out preventive and breakdown maintenance to fixed and mobile plant&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/mining-electrician-traveling\/\" name=\"Mining Electrician- Traveling\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"This role will be performed near Wright, WY and&nbsp;will carry out preventive and breakdown maintenance to fixed and mobile plant&hellip;","address":"Wright, WY, USA","location":{"lat":"43.7518832","city":"Wright","state":"WY","country":"United States","lng":"-105.4913345","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/mining-electrician-traveling\/","zoom":19,"extra_fields":{"post_excerpt":"This role will be performed near Wright, WY and&nbsp;will carry out preventive and breakdown maintenance to fixed and mobile plant&hellip;","post_content":"<p>This role will be performed near Wright, WY and&nbsp;will carry out preventive and breakdown maintenance to fixed and mobile plant in an open cut environments.<\/p>\n<p><\/p>\n<p>Duties will include:<\/p>\n<ul><li>Visibly support and champion our client's Mission and Values<\/li><li>Act in accordance with and adhere to Safety as a Way of Life Management System<\/li><\/ul>\n<ul><li>Inspect work area and plant for hazards, damage and defects<\/li><li>Examine drawings or specifications to determine work methods, sequence of activities or manufacture of components<\/li><li>Diagnose faults or breakdowns<\/li><li>Estimate time and materials required to complete jobs<\/li><li>Raise orders for materials<\/li><li>Undertake repairs or component changeouts as required<\/li><li>Clean and maintain tools and work area<\/li><li>Train other personnel or apprentices (if required)<\/li><li>Ensure activities comply with safety, environmental and statutory requirements<\/li><li>Other duties as assigned by the company<\/li><\/ul>\n<p><\/p>\n<p><strong>The Lifestyle:<\/strong><\/p>\n<p>This position may require the necessity to work weekends, holidays, or another shift as deemed necessary.&nbsp;&nbsp;&nbsp;<br><\/p>\n<p><\/p>\n<p><strong>About you:<\/strong><\/p>\n<ul><li>Three years\u2019 experience performing electrical maintenance work in a heavy industrial environment or mine site is preferred.<\/li><li>Ability to solve problems and troubleshoot situations arising in the pit area as needed.<\/li><li>Ability to work in all types of weather conditions and at different times of day.<\/li><li>Ability to work a flexible schedule as required by business need.<\/li><li>Ability to work rotating shifts, weekends and overtime when required.<\/li><li>High School Degree or GED Equivalent required<\/li><\/ul>\n<p><\/p>\n<p><strong>Physical Requirements - Surface:<\/strong><\/p>\n<ul><li>Must have the ability to stand for up to 4 hours per shift<\/li><li>Must have the ability to be seated for up to 4 hours to operate equipment or vehicles<\/li><li>Must have the ability to work from elevated positions, walk\/climb up and down stairs\/steps and climb on and off equipment and ladders<\/li><li>Must have the ability to wear required protective footwear, hearing and eye protection, and other personal protective equipment as required by Company and MSHA<\/li><li>Must have the ability to perform repetitive hand and wrist motions (push, pull, twist, handle), and have rapid reflex movements of the arms and legs and good hand to eye coordination<\/li><li>Must have the ability to lift\/raise 10 - 50 lbs. without mechanical assistance frequently during the course of work shift&nbsp;<\/li><li>Must have the ability to work in extreme conditions, including but not limited to changing weather conditions, dust, mud, varying levels of noise from low to high, varying degrees of light and dark, in and around artificial light and in a confined work area<\/li><li>The job requires that you be able to work various shifts (required shifts include days, evenings and nights with rotating schedules, weekends and holidays&nbsp;&nbsp;&nbsp;<\/li><\/ul>","post_title":"Mining Electrician- Traveling","post_link":"https:\/\/turnerstaffing.com\/position\/mining-electrician-traveling\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Mid Level","%location_country%":"United States","%location_city%":"Wright","%location_state_id%":"WY","%location_state_name%":"Wyoming","%location_city_state%":"Wright, WY","%education%":"High School or equivalent","%department%":"","%description%":"<p>This role will be performed near Wright, WY and&nbsp;will carry out preventive and breakdown maintenance to fixed and mobile plant in an open cut environments.<\/p>\n<p><\/p>\n<p>Duties will include:<\/p>\n<ul><li>Visibly support and champion our client's Mission and Values<\/li><li>Act in accordance with and adhere to Safety as a Way of Life Management System<\/li><\/ul>\n<ul><li>Inspect work area and plant for hazards, damage and defects<\/li><li>Examine drawings or specifications to determine work methods, sequence of activities or manufacture of components<\/li><li>Diagnose faults or breakdowns<\/li><li>Estimate time and materials required to complete jobs<\/li><li>Raise orders for materials<\/li><li>Undertake repairs or component changeouts as required<\/li><li>Clean and maintain tools and work area<\/li><li>Train other personnel or apprentices (if required)<\/li><li>Ensure activities comply with safety, environmental and statutory requirements<\/li><li>Other duties as assigned by the company<\/li><\/ul>\n<p><\/p>\n<p><strong>The Lifestyle:<\/strong><\/p>\n<p>This position may require the necessity to work weekends, holidays, or another shift as deemed necessary.&nbsp;&nbsp;&nbsp;<br><\/p>\n<p><\/p>\n<p><strong>About you:<\/strong><\/p>\n<ul><li>Three years\u2019 experience performing electrical maintenance work in a heavy industrial environment or mine site is preferred.<\/li><li>Ability to solve problems and troubleshoot situations arising in the pit area as needed.<\/li><li>Ability to work in all types of weather conditions and at different times of day.<\/li><li>Ability to work a flexible schedule as required by business need.<\/li><li>Ability to work rotating shifts, weekends and overtime when required.<\/li><li>High School Degree or GED Equivalent required<\/li><\/ul>\n<p><\/p>\n<p><strong>Physical Requirements - Surface:<\/strong><\/p>\n<ul><li>Must have the ability to stand for up to 4 hours per shift<\/li><li>Must have the ability to be seated for up to 4 hours to operate equipment or vehicles<\/li><li>Must have the ability to work from elevated positions, walk\/climb up and down stairs\/steps and climb on and off equipment and ladders<\/li><li>Must have the ability to wear required protective footwear, hearing and eye protection, and other personal protective equipment as required by Company and MSHA<\/li><li>Must have the ability to perform repetitive hand and wrist motions (push, pull, twist, handle), and have rapid reflex movements of the arms and legs and good hand to eye coordination<\/li><li>Must have the ability to lift\/raise 10 - 50 lbs. without mechanical assistance frequently during the course of work shift&nbsp;<\/li><li>Must have the ability to work in extreme conditions, including but not limited to changing weather conditions, dust, mud, varying levels of noise from low to high, varying degrees of light and dark, in and around artificial light and in a confined work area<\/li><li>The job requires that you be able to work various shifts (required shifts include days, evenings and nights with rotating schedules, weekends and holidays&nbsp;&nbsp;&nbsp;<\/li><\/ul>","%category%":"Operations","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/85d3d532684e-mining-electrician-traveling","%breezy_id%":"85d3d532684e","%breezy_friendly_id%":"85d3d532684e-mining-electrician-traveling","%breezy_created_date%":"2025-09-16T15:47:30.767Z","%breezy_updated_date%":"2026-01-21T21:46:23.126Z","%_wpgmp_location_city%":"Wright","%_wpgmp_location_state%":"WY","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Wright, WY, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"43.7518832","%_wpgmp_metabox_longitude%":"-105.4913345","%rank_math_internal_links_processed%":"1"}},"id":2757,"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":"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\/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%":"kermit","%location_state_id%":"TX","%location_state_name%":"Texas","%location_city_state%":"kermit, 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%":"2026-01-12T15:51:59.892Z","%_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":2742,"infowindow_disable":false},{"source":"post","title":"Fuel\/Lube Technician &#8211; Mining","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Fuel\/Lube Technician &#8211; Mining\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Turner Mining Group &#8211; Heavy Equipment Fuel &amp; Lube TechnicianWe are looking for a dynamic and talented professional to fill&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/fuel-lube-technician-mining-2\/\" name=\"Fuel\/Lube Technician &#8211; Mining\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Turner Mining Group &#8211; Heavy Equipment Fuel &amp; Lube TechnicianWe are looking for a dynamic and talented professional to fill&hellip;","address":"Crane, TX, USA","location":{"lat":"31.3973624","city":"Crane","state":"TX","country":"United States","lng":"-102.3501419","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/fuel-lube-technician-mining-2\/","zoom":19,"extra_fields":{"post_excerpt":"Turner Mining Group &#8211; Heavy Equipment Fuel &amp; Lube TechnicianWe are looking for a dynamic and talented professional to fill&hellip;","post_content":"<p><strong><u>Turner Mining Group - Heavy Equipment Fuel &amp; Lube Technician<\/u><\/strong><br>We are looking for a dynamic and talented professional to fill a <strong>Fuel &amp; Lube Technician<\/strong> role at our fast-growing, forward thinking mining services company.<\/p>\n\n<p style=\"color:#000000\"><span style=\"color:#333333\"> <\/span><\/p>\n<p>This person will function as a <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> <span style=\"color:#333333\"><\/span><\/p>\n\n\n<p><strong>Essential Skills &amp; Knowledge<\/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 minor repairs on equipment using tools, machine tools and measuring instruments <\/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 Operate and test 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\"><span style=\"color:#333333\"> <\/span><\/p>\n<p><strong>Benefits<\/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\"> <\/span><\/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>\n<p><\/p>","post_title":"Fuel\/Lube Technician &#8211; Mining","post_link":"https:\/\/turnerstaffing.com\/position\/fuel-lube-technician-mining-2\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Entry Level","%location_country%":"United States","%location_city%":"Crane","%location_state_id%":"TX","%location_state_name%":"Texas","%location_city_state%":"Crane, TX","%education%":"Unspecified","%department%":"Maintenance","%description%":"<p><strong><u>Turner Mining Group - Heavy Equipment Fuel &amp; Lube Technician<\/u><\/strong><br>We are looking for a dynamic and talented professional to fill a <strong>Fuel &amp; Lube Technician<\/strong> role at our fast-growing, forward thinking mining services company.<\/p>\n\n<p style=\"color:#000000;\"><span style=\"color:#333333;\"> <\/span><\/p>\n<p>This person will function as a <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> <span style=\"color:#333333;\"><\/span><\/p>\n\n\n<p><strong>Essential Skills &amp; Knowledge<\/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 minor repairs on equipment using tools, machine tools and measuring instruments <\/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 Operate and test 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;\"><span style=\"color:#333333;\"> <\/span><\/p>\n<p><strong>Benefits<\/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;\"> <\/span><\/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>\n<p><\/p>","%category%":"Operations","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/5864776f7e51-fuel-lube-technician-mining","%breezy_id%":"5864776f7e51","%breezy_friendly_id%":"5864776f7e51-fuel-lube-technician-mining","%breezy_created_date%":"2025-09-04T22:39:05.688Z","%breezy_updated_date%":"2025-12-29T21:17:57.043Z","%_wpgmp_location_city%":"Crane","%_wpgmp_location_state%":"TX","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Crane, TX, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"31.3973624","%_wpgmp_metabox_longitude%":"-102.3501419","%rank_math_internal_links_processed%":"1"}},"id":2723,"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    Turner Mining Group &#8211; Heavy Equipment Fuel &amp; Lube Technician Do you love mining? Do you think differently? Are you&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":"Turner Mining Group &#8211; Heavy Equipment Fuel &amp; Lube Technician Do you love mining? Do you think differently? Are you&hellip;","address":"Crane, TX, USA","location":{"lat":"31.3973624","city":"Crane","state":"TX","country":"United States","lng":"-102.3501419","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/heavy-equipment-fuel-lube-technician-3\/","zoom":19,"extra_fields":{"post_excerpt":"Turner Mining Group &#8211; Heavy Equipment Fuel &amp; Lube Technician Do you love mining? Do you think differently? Are you&hellip;","post_content":"<p><strong><u>Turner Mining Group - Heavy Equipment Fuel &amp; Lube Technician<\/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\n<p>We are looking for a dynamic and talented professional to fill a <strong>Fuel &amp; Lube Technician<\/strong> role at our fast-growing, forward thinking mining services company.<\/p>\n<p style=\"color:#000000\"><span style=\"color:#333333\"> <\/span><\/p>\n<p>This person will function as a <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> <span style=\"color:#333333\"><\/span><\/p>\n\n\n<p><strong>Essential Skills &amp; Knowledge<\/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 minor repairs on equipment using tools, machine tools and measuring instruments <\/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 Operate and test 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\"><span style=\"color:#333333\"> <\/span><\/p>\n<p><strong>Benefits<\/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\"> <\/span><\/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>\n<p><\/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%":"Crane","%location_state_id%":"TX","%location_state_name%":"Texas","%location_city_state%":"Crane, TX","%education%":"","%department%":"Equipment","%description%":"<p><strong><u>Turner Mining Group - Heavy Equipment Fuel &amp; Lube Technician<\/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\n<p>We are looking for a dynamic and talented professional to fill a <strong>Fuel &amp; Lube Technician<\/strong> role at our fast-growing, forward thinking mining services company.<\/p>\n<p style=\"color:#000000;\"><span style=\"color:#333333;\"> <\/span><\/p>\n<p>This person will function as a <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> <span style=\"color:#333333;\"><\/span><\/p>\n\n\n<p><strong>Essential Skills &amp; Knowledge<\/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 minor repairs on equipment using tools, machine tools and measuring instruments <\/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 Operate and test 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;\"><span style=\"color:#333333;\"> <\/span><\/p>\n<p><strong>Benefits<\/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;\"> <\/span><\/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>\n<p><\/p>","%category%":"","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/e9a5df43ef43-heavy-equipment-fuel-lube-technician","%breezy_id%":"e9a5df43ef43","%breezy_friendly_id%":"e9a5df43ef43-heavy-equipment-fuel-lube-technician","%breezy_created_date%":"2022-10-27T14:56:27.823Z","%breezy_updated_date%":"2025-12-26T17:39:53.804Z","%_wpgmp_location_city%":"Crane","%_wpgmp_location_state%":"TX","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Crane, TX, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"31.3973624","%_wpgmp_metabox_longitude%":"-102.3501419","%rank_math_internal_links_processed%":"1"}},"id":2710,"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-4\/\" 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-4\/","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-4\/","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-09-03T00:08:25.217Z","%_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":2709,"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-12\/\" 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":"Lamesa, TX, USA","location":{"lat":"32.7376001","city":"Lamesa","state":"TX","country":"United States","lng":"-101.950992","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/haul-truck-driver-12\/","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","post_link":"https:\/\/turnerstaffing.com\/position\/haul-truck-driver-12\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Associate","%location_country%":"United States","%location_city%":"Lamesa","%location_state_id%":"TX","%location_state_name%":"Texas","%location_city_state%":"Lamesa, TX","%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\/90e63451a601-haul-truck-driver","%breezy_id%":"90e63451a601","%breezy_friendly_id%":"90e63451a601-haul-truck-driver","%breezy_created_date%":"2025-02-14T16:12:03.183Z","%breezy_updated_date%":"2025-11-20T16:30:14.805Z","%_wpgmp_location_city%":"Lamesa","%_wpgmp_location_state%":"TX","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Lamesa, TX, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"32.7376001","%_wpgmp_metabox_longitude%":"-101.950992","%rank_math_internal_links_processed%":"1"}},"id":2682,"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 Staffing Group \u2013 Haul Truck Driver You You want to work for a services company that is rapidly changing&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/haul-truck-driver-11\/\" name=\"Haul Truck Driver\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Turner Staffing Group \u2013 Haul Truck Driver You You want to work for a services company that is rapidly changing&hellip;","address":"Lovelock, NV, USA","location":{"lat":"40.1793537","city":"Lovelock","state":"NV","country":"United States","lng":"-118.4734808","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/haul-truck-driver-11\/","zoom":19,"extra_fields":{"post_excerpt":"Turner Staffing Group \u2013 Haul Truck Driver You You want to work for a services company that is rapidly changing&hellip;","post_content":"<p><strong><u>Turner Staffing Group \u2013 Haul Truck Driver<\/u><\/strong><br><\/p>\n\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>","post_title":"Haul Truck Driver","post_link":"https:\/\/turnerstaffing.com\/position\/haul-truck-driver-11\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Mid Level","%location_country%":"United States","%location_city%":"Lovelock","%location_state_id%":"NV","%location_state_name%":"Nevada","%location_city_state%":"Lovelock, NV","%education%":"Unspecified","%department%":"","%description%":"<p><strong><u>Turner Staffing Group \u2013 Haul Truck Driver<\/u><\/strong><br><\/p>\n\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>","%category%":"Operations","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/a2dc90e7ee34-haul-truck-driver","%breezy_id%":"a2dc90e7ee34","%breezy_friendly_id%":"a2dc90e7ee34-haul-truck-driver","%breezy_created_date%":"2025-08-05T16:00:58.384Z","%breezy_updated_date%":"2025-11-14T20:41:35.016Z","%_wpgmp_location_city%":"Lovelock","%_wpgmp_location_state%":"NV","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Lovelock, NV, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"40.1793537","%_wpgmp_metabox_longitude%":"-118.4734808","%rank_math_internal_links_processed%":"1"}},"id":2676,"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    Job Summary: We are seeking a dependable and safety-conscious Haul Truck Driver for a 3 to 6-month contract position based&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/haul-truck-driver-8\/\" name=\"Haul Truck Driver\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Job Summary: We are seeking a dependable and safety-conscious Haul Truck Driver for a 3 to 6-month contract position based&hellip;","address":"Winston-Salem, NC, USA","location":{"lat":"36.0948221","city":"Winston-Salem","state":"NC","country":"United States","lng":"-80.2434028","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/haul-truck-driver-8\/","zoom":19,"extra_fields":{"post_excerpt":"Job Summary: We are seeking a dependable and safety-conscious Haul Truck Driver for a 3 to 6-month contract position based&hellip;","post_content":"<h3><strong>Job Summary:<\/strong><\/h3>\n<p>We are seeking a dependable and safety-conscious <strong>Haul Truck Driver<\/strong> for a <strong>3 to 6-month contract<\/strong> position based in <strong>Winston-Salem, NC<\/strong>. This role requires <strong>extensive travel throughout North Carolina and South Carolina<\/strong> to support multiple project sites. The ideal candidate will have experience operating heavy haul trucks on construction and mining sites, a strong work ethic, and a commitment to safety and efficiency.<\/p>\n<h3><strong>Key Responsibilities:<\/strong><\/h3>\n<ul>\n<li>\n<p>Operate off-road haul trucks to transport materials such as dirt, rock, and other aggregates across various project sites.<\/p>\n<\/li>\n<li>\n<p>Perform daily pre-operational checks and basic maintenance on assigned equipment.<\/p>\n<\/li>\n<li>\n<p>Safely load and unload materials and coordinate with site supervisors and equipment operators.<\/p>\n<\/li>\n<li>\n<p>Ensure all loads are secure and comply with DOT and site safety regulations.<\/p>\n<\/li>\n<li>\n<p>Maintain accurate delivery logs and time records.<\/p>\n<\/li>\n<li>\n<p>Follow all safety procedures and company policies while on-site and in transit.<\/p>\n<\/li>\n<li>\n<p>Travel to job sites throughout North Carolina and South Carolina as required by project needs.<\/p>\n<\/li>\n<\/ul>\n<h3><strong>Qualifications:<\/strong><\/h3>\n<ul>\n<li>\n<p>Proven experience operating off-road or articulated haul trucks (CAT, Volvo, Komatsu, etc.)<\/p>\n<\/li>\n<li>\n<p>Valid driver\u2019s license; CDL preferred but not required<\/p>\n<\/li>\n<li>\n<p>Willingness and ability to travel regularly throughout NC and SC<\/p>\n<\/li>\n<li>\n<p>Strong commitment to workplace safety and environmental compliance<\/p>\n<\/li>\n<li>\n<p>Ability to work independently with minimal supervision<\/p>\n<\/li>\n<li>\n<p>Reliable transportation to and from job sites or designated meeting locations<\/p>\n<\/li>\n<\/ul>\n<h3><strong>Preferred:<\/strong><\/h3>\n<ul>\n<li>\n<p>OSHA 10 or MSHA certification<\/p>\n<\/li>\n<li>\n<p>Experience on construction or mining sites<\/p>\n<\/li>\n<li>\n<p>Ability to operate other heavy equipment a plus<\/p><\/li><\/ul>","post_title":"Haul Truck Driver","post_link":"https:\/\/turnerstaffing.com\/position\/haul-truck-driver-8\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Contract","%experience%":"Associate","%location_country%":"United States","%location_city%":"Winston-Salem","%location_state_id%":"NC","%location_state_name%":"North Carolina","%location_city_state%":"Winston-Salem, NC","%education%":"Unspecified","%department%":"","%description%":"<h3><strong>Job Summary:<\/strong><\/h3>\n<p>We are seeking a dependable and safety-conscious <strong>Haul Truck Driver<\/strong> for a <strong>3 to 6-month contract<\/strong> position based in <strong>Winston-Salem, NC<\/strong>. This role requires <strong>extensive travel throughout North Carolina and South Carolina<\/strong> to support multiple project sites. The ideal candidate will have experience operating heavy haul trucks on construction and mining sites, a strong work ethic, and a commitment to safety and efficiency.<\/p>\n<h3><strong>Key Responsibilities:<\/strong><\/h3>\n<ul>\n<li>\n<p>Operate off-road haul trucks to transport materials such as dirt, rock, and other aggregates across various project sites.<\/p>\n<\/li>\n<li>\n<p>Perform daily pre-operational checks and basic maintenance on assigned equipment.<\/p>\n<\/li>\n<li>\n<p>Safely load and unload materials and coordinate with site supervisors and equipment operators.<\/p>\n<\/li>\n<li>\n<p>Ensure all loads are secure and comply with DOT and site safety regulations.<\/p>\n<\/li>\n<li>\n<p>Maintain accurate delivery logs and time records.<\/p>\n<\/li>\n<li>\n<p>Follow all safety procedures and company policies while on-site and in transit.<\/p>\n<\/li>\n<li>\n<p>Travel to job sites throughout North Carolina and South Carolina as required by project needs.<\/p>\n<\/li>\n<\/ul>\n<h3><strong>Qualifications:<\/strong><\/h3>\n<ul>\n<li>\n<p>Proven experience operating off-road or articulated haul trucks (CAT, Volvo, Komatsu, etc.)<\/p>\n<\/li>\n<li>\n<p>Valid driver\u2019s license; CDL preferred but not required<\/p>\n<\/li>\n<li>\n<p>Willingness and ability to travel regularly throughout NC and SC<\/p>\n<\/li>\n<li>\n<p>Strong commitment to workplace safety and environmental compliance<\/p>\n<\/li>\n<li>\n<p>Ability to work independently with minimal supervision<\/p>\n<\/li>\n<li>\n<p>Reliable transportation to and from job sites or designated meeting locations<\/p>\n<\/li>\n<\/ul>\n<h3><strong>Preferred:<\/strong><\/h3>\n<ul>\n<li>\n<p>OSHA 10 or MSHA certification<\/p>\n<\/li>\n<li>\n<p>Experience on construction or mining sites<\/p>\n<\/li>\n<li>\n<p>Ability to operate other heavy equipment a plus<\/p><\/li><\/ul>","%category%":"Operations","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/58973445f689-haul-truck-driver","%breezy_id%":"58973445f689","%breezy_friendly_id%":"58973445f689-haul-truck-driver","%breezy_created_date%":"2025-08-01T13:24:15.989Z","%breezy_updated_date%":"2025-11-14T20:41:34.079Z","%_wpgmp_location_city%":"Winston-Salem","%_wpgmp_location_state%":"NC","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Winston-Salem, NC, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"36.0948221","%_wpgmp_metabox_longitude%":"-80.2434028","%rank_math_internal_links_processed%":"1"}},"id":2651,"infowindow_disable":false},{"source":"post","title":"Fabricator","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Fabricator\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Position Overview The fabricator is responsible for things that include the fabrication of handrails, walkways, decks, drill tooling, and support&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/fabricator\/\" name=\"Fabricator\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Position Overview The fabricator is responsible for things that include the fabrication of handrails, walkways, decks, drill tooling, and support&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\/fabricator\/","zoom":19,"extra_fields":{"post_excerpt":"Position Overview The fabricator is responsible for things that include the fabrication of handrails, walkways, decks, drill tooling, and support&hellip;","post_content":"<p>Position Overview<\/p>\n<p>The fabricator is responsible for things that include the fabrication of handrails, walkways, decks, drill<\/p>\n<p>tooling, and support equipment. You may also weld casing or other fabrication projects as needed both<\/p>\n<p>in the shop and within the field.<\/p>\n<p>\uf0b7 This is a non-exempt, hourly position.<\/p>\n<p>\uf0b7 Fabricators can work a 10 days on \/ 4 days off, or a 9 days on \/ 5 days off schedule.<\/p>\n<p>Essential Functions<\/p>\n<p>\uf0b7 Demonstrate a strong commitment to safe work practices and procedures.<\/p>\n<p>\uf0b7 Repair and replace damaged or worn parts.<\/p>\n<p>\uf0b7 Repair and fabricate damaged or worn parts.<\/p>\n<p>\uf0b7 Dismantle and reassemble heavy equipment using hoists and hand tools.<\/p>\n<p>\uf0b7 Examine parts for damage or excessive wear using micrometers and gauges.<\/p>\n<p>\uf0b7 Read and understand blueprints and technical drawings.<\/p>\n<p>\uf0b7 Weld broken parts and structural members using Tig, Mig, and Arc welding. Some soldering and<\/p>\n<p>gas welding.<\/p>\n<p>\uf0b7 Weld and fabricate Items such as Drilling-related parts such as Well heads, Casing, Landing<\/p>\n<p>plates, Handrails, Walkways, Guards, etc.<\/p>\n<p>\uf0b7 Fabricate needed parts or items as required.<\/p>\n<p>\uf0b7 Exhibit a strong work ethic with the drive and desire to learn and perform tasks efficiently.<\/p>\n<p>\uf0b7 Maintain effective and collaborative workplace relationships, treating others with dignity and<\/p>\n<p>respect.<\/p>\n<p>Qualifications<\/p>\n<p>\uf0b7 Must pass a pre-employment physical, drug (including the use of marijuana) and alcohol<\/p>\n<p>screening, Motor Vehicle Report (MVR), and additional background screening as required by<\/p>\n<p>regulation and\/or industry practice.<\/p>\n<p>\uf0b7 Must have a valid driver's license.<\/p>\n<p>\uf0b7 Must have experience with MIG, TIG, and ARC welding.<\/p>\n<p>\uf0b7 Knowledge and ability to use a CNC plasma table and CNC brake press.<\/p>\n<p>\uf0b7 Knowledge of manual mill and lathe.<\/p>\n<p>\uf0b7 Knowledge and ability to properly set and adjust the machine for welding.<\/p>\n<p>\uf0b7 Knowledge and ability to operate an ironworker and tubing bender.<\/p>\n<p>\uf0b7 Ability to read blueprints.<\/p>\n<p>\uf0b7 Experience repairing and maintaining mechanical equipment.<\/p>\n<p>\uf0b7 Strong attention to detail and ability to safely use and operate shop tools and equipment such as<\/p>\n<p>torches, band saws, ironworkers, and drill presses.<\/p>\n<p>\uf0b7 Safely operate forklifts, other lift equipment, and\/or cranes to move material as required.<\/p>\n<p>\uf0b7 Must be able to lift 100 lbs.<\/p>\n<p>\uf0b7 Must be able to stand for long periods of time and push, pull, reach, climb, bend, twist, squat,<\/p>\n<p>and kneel multiple times per shift.<\/p>\n<p>\uf0b7 Must be willing to travel and work in remote locations, outside, and in all weather conditions<\/p>\n<p>(hot and cold).<\/p>\n<p>\uf0b7 Ability to add, subtract, multiply, and divide in all units of measure, using whole numbers,<\/p>\n<p>common fractions, and decimals.<\/p>","post_title":"Fabricator","post_link":"https:\/\/turnerstaffing.com\/position\/fabricator\/","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>Position Overview<\/p>\n<p>The fabricator is responsible for things that include the fabrication of handrails, walkways, decks, drill<\/p>\n<p>tooling, and support equipment. You may also weld casing or other fabrication projects as needed both<\/p>\n<p>in the shop and within the field.<\/p>\n<p>\uf0b7 This is a non-exempt, hourly position.<\/p>\n<p>\uf0b7 Fabricators can work a 10 days on \/ 4 days off, or a 9 days on \/ 5 days off schedule.<\/p>\n<p>Essential Functions<\/p>\n<p>\uf0b7 Demonstrate a strong commitment to safe work practices and procedures.<\/p>\n<p>\uf0b7 Repair and replace damaged or worn parts.<\/p>\n<p>\uf0b7 Repair and fabricate damaged or worn parts.<\/p>\n<p>\uf0b7 Dismantle and reassemble heavy equipment using hoists and hand tools.<\/p>\n<p>\uf0b7 Examine parts for damage or excessive wear using micrometers and gauges.<\/p>\n<p>\uf0b7 Read and understand blueprints and technical drawings.<\/p>\n<p>\uf0b7 Weld broken parts and structural members using Tig, Mig, and Arc welding. Some soldering and<\/p>\n<p>gas welding.<\/p>\n<p>\uf0b7 Weld and fabricate Items such as Drilling-related parts such as Well heads, Casing, Landing<\/p>\n<p>plates, Handrails, Walkways, Guards, etc.<\/p>\n<p>\uf0b7 Fabricate needed parts or items as required.<\/p>\n<p>\uf0b7 Exhibit a strong work ethic with the drive and desire to learn and perform tasks efficiently.<\/p>\n<p>\uf0b7 Maintain effective and collaborative workplace relationships, treating others with dignity and<\/p>\n<p>respect.<\/p>\n<p>Qualifications<\/p>\n<p>\uf0b7 Must pass a pre-employment physical, drug (including the use of marijuana) and alcohol<\/p>\n<p>screening, Motor Vehicle Report (MVR), and additional background screening as required by<\/p>\n<p>regulation and\/or industry practice.<\/p>\n<p>\uf0b7 Must have a valid driver's license.<\/p>\n<p>\uf0b7 Must have experience with MIG, TIG, and ARC welding.<\/p>\n<p>\uf0b7 Knowledge and ability to use a CNC plasma table and CNC brake press.<\/p>\n<p>\uf0b7 Knowledge of manual mill and lathe.<\/p>\n<p>\uf0b7 Knowledge and ability to properly set and adjust the machine for welding.<\/p>\n<p>\uf0b7 Knowledge and ability to operate an ironworker and tubing bender.<\/p>\n<p>\uf0b7 Ability to read blueprints.<\/p>\n<p>\uf0b7 Experience repairing and maintaining mechanical equipment.<\/p>\n<p>\uf0b7 Strong attention to detail and ability to safely use and operate shop tools and equipment such as<\/p>\n<p>torches, band saws, ironworkers, and drill presses.<\/p>\n<p>\uf0b7 Safely operate forklifts, other lift equipment, and\/or cranes to move material as required.<\/p>\n<p>\uf0b7 Must be able to lift 100 lbs.<\/p>\n<p>\uf0b7 Must be able to stand for long periods of time and push, pull, reach, climb, bend, twist, squat,<\/p>\n<p>and kneel multiple times per shift.<\/p>\n<p>\uf0b7 Must be willing to travel and work in remote locations, outside, and in all weather conditions<\/p>\n<p>(hot and cold).<\/p>\n<p>\uf0b7 Ability to add, subtract, multiply, and divide in all units of measure, using whole numbers,<\/p>\n<p>common fractions, and decimals.<\/p>","%category%":"","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/73983223a43d-fabricator","%breezy_id%":"73983223a43d","%breezy_friendly_id%":"73983223a43d-fabricator","%breezy_created_date%":"2025-07-28T17:57:45.793Z","%breezy_updated_date%":"2025-11-14T20:41:06.694Z","%_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":2637,"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\/\" 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":"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 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><\/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!<\/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\/","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%":"<p><strong><u>Turner Mining Group \u2013 Heavy Equipment Operator<\/u><\/strong><\/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!<\/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\/8469c68f2297-dozer-operator","%breezy_id%":"8469c68f2297","%breezy_friendly_id%":"8469c68f2297-dozer-operator","%breezy_created_date%":"2025-07-20T15:18:10.210Z","%breezy_updated_date%":"2025-11-14T20:40:37.208Z","%_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":2614,"infowindow_disable":false},{"source":"post","title":"Welder","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Welder\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Job Summary: We are seeking a skilled and safety-conscious Welder to join our team in Tucson, AZ. The ideal candidate&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/welder\/\" name=\"Welder\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Job Summary: We are seeking a skilled and safety-conscious Welder to join our team in Tucson, AZ. The ideal candidate&hellip;","address":"Tucson, AZ, USA","location":{"lat":"32.2539787","city":"Tucson","state":"AZ","country":"United States","lng":"-110.9741769","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/welder\/","zoom":19,"extra_fields":{"post_excerpt":"Job Summary: We are seeking a skilled and safety-conscious Welder to join our team in Tucson, AZ. The ideal candidate&hellip;","post_content":"<h3><strong>Job Summary:<\/strong><\/h3>\n<p>We are seeking a skilled and safety-conscious <strong>Welder<\/strong> to join our team in <strong>Tucson, AZ<\/strong>. The ideal candidate will have hands-on experience with <strong>MIG (Gas Metal Arc Welding), stick welding (SMAW), and air arc gouging<\/strong>, and be capable of working in a fast-paced industrial or fabrication environment. This role involves interpreting blueprints, performing high-quality welds, and contributing to a strong culture of safety and teamwork.<\/p>\n<h3><strong>Key Responsibilities:<\/strong><\/h3>\n<ul>\n<li>\n<p>Perform welding tasks using <strong>MIG, stick (SMAW), and air arcing (carbon arc gouging)<\/strong> techniques.<\/p>\n<\/li>\n<li>\n<p>Read and interpret blueprints, technical drawings, and welding specifications.<\/p>\n<\/li>\n<li>\n<p>Set up and operate welding equipment according to job specifications and safety standards.<\/p>\n<\/li>\n<li>\n<p>Inspect welds for quality and conformance to standards using visual inspection and measuring tools.<\/p>\n<\/li>\n<li>\n<p>Prepare metal surfaces for welding by cutting, grinding, and cleaning as required.<\/p>\n<\/li>\n<li>\n<p>Operate grinders, cutting torches, and other fabrication tools safely and efficiently.<\/p>\n<\/li>\n<li>\n<p>Follow all safety protocols and participate in regular safety meetings and training.<\/p>\n<\/li>\n<li>\n<p>Work independently or as part of a team to complete welding projects on time.<\/p>\n<\/li>\n<li>\n<p>Maintain tools and equipment in proper working condition.<\/p>\n<\/li>\n<\/ul>\n<h3><strong>Qualifications:<\/strong><\/h3>\n<ul>\n<li>\n<p><strong>3+ years<\/strong> of welding experience, preferably in an industrial or construction setting.<\/p>\n<\/li>\n<li>\n<p>Proficiency in <strong>MIG, stick (SMAW), and air arc gouging<\/strong> required.<\/p>\n<\/li>\n<li>\n<p>Ability to read blueprints and welding symbols.<\/p>\n<\/li>\n<li>\n<p>Experience with heavy fabrication and structural welding preferred.<\/p>\n<\/li>\n<li>\n<p>Must pass a weld test as part of the hiring process.<\/p>\n<\/li>\n<li>\n<p>Familiarity with OSHA safety standards.<\/p>\n<\/li>\n<li>\n<p>High school diploma or GED; welding certification or trade school a plus.<\/p>\n<\/li>\n<li>\n<p>Ability to lift up to 50 lbs and work in various positions (standing, bending, overhead).<\/p>\n<\/li>\n<\/ul>\n<h3><strong>Preferred Qualifications:<\/strong><\/h3>\n<ul>\n<li>\n<p>AWS or equivalent welding certification.<\/p>\n<\/li>\n<li>\n<p>Bilingual (English\/Spanish) is a plus.<\/p>\n<\/li>\n<li>\n<p>Experience in mining, construction, or heavy equipment repair is beneficial.<\/p><\/li><\/ul>","post_title":"Welder","post_link":"https:\/\/turnerstaffing.com\/position\/welder\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"","%location_country%":"United States","%location_city%":"Tucson","%location_state_id%":"AZ","%location_state_name%":"Arizona","%location_city_state%":"Tucson, AZ","%education%":"","%department%":"","%description%":"<h3><strong>Job Summary:<\/strong><\/h3>\n<p>We are seeking a skilled and safety-conscious <strong>Welder<\/strong> to join our team in <strong>Tucson, AZ<\/strong>. The ideal candidate will have hands-on experience with <strong>MIG (Gas Metal Arc Welding), stick welding (SMAW), and air arc gouging<\/strong>, and be capable of working in a fast-paced industrial or fabrication environment. This role involves interpreting blueprints, performing high-quality welds, and contributing to a strong culture of safety and teamwork.<\/p>\n<h3><strong>Key Responsibilities:<\/strong><\/h3>\n<ul>\n<li>\n<p>Perform welding tasks using <strong>MIG, stick (SMAW), and air arcing (carbon arc gouging)<\/strong> techniques.<\/p>\n<\/li>\n<li>\n<p>Read and interpret blueprints, technical drawings, and welding specifications.<\/p>\n<\/li>\n<li>\n<p>Set up and operate welding equipment according to job specifications and safety standards.<\/p>\n<\/li>\n<li>\n<p>Inspect welds for quality and conformance to standards using visual inspection and measuring tools.<\/p>\n<\/li>\n<li>\n<p>Prepare metal surfaces for welding by cutting, grinding, and cleaning as required.<\/p>\n<\/li>\n<li>\n<p>Operate grinders, cutting torches, and other fabrication tools safely and efficiently.<\/p>\n<\/li>\n<li>\n<p>Follow all safety protocols and participate in regular safety meetings and training.<\/p>\n<\/li>\n<li>\n<p>Work independently or as part of a team to complete welding projects on time.<\/p>\n<\/li>\n<li>\n<p>Maintain tools and equipment in proper working condition.<\/p>\n<\/li>\n<\/ul>\n<h3><strong>Qualifications:<\/strong><\/h3>\n<ul>\n<li>\n<p><strong>3+ years<\/strong> of welding experience, preferably in an industrial or construction setting.<\/p>\n<\/li>\n<li>\n<p>Proficiency in <strong>MIG, stick (SMAW), and air arc gouging<\/strong> required.<\/p>\n<\/li>\n<li>\n<p>Ability to read blueprints and welding symbols.<\/p>\n<\/li>\n<li>\n<p>Experience with heavy fabrication and structural welding preferred.<\/p>\n<\/li>\n<li>\n<p>Must pass a weld test as part of the hiring process.<\/p>\n<\/li>\n<li>\n<p>Familiarity with OSHA safety standards.<\/p>\n<\/li>\n<li>\n<p>High school diploma or GED; welding certification or trade school a plus.<\/p>\n<\/li>\n<li>\n<p>Ability to lift up to 50 lbs and work in various positions (standing, bending, overhead).<\/p>\n<\/li>\n<\/ul>\n<h3><strong>Preferred Qualifications:<\/strong><\/h3>\n<ul>\n<li>\n<p>AWS or equivalent welding certification.<\/p>\n<\/li>\n<li>\n<p>Bilingual (English\/Spanish) is a plus.<\/p>\n<\/li>\n<li>\n<p>Experience in mining, construction, or heavy equipment repair is beneficial.<\/p><\/li><\/ul>","%category%":"","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/c62136f25f3d-welder","%breezy_id%":"c62136f25f3d","%breezy_friendly_id%":"c62136f25f3d-welder","%breezy_created_date%":"2025-07-17T15:09:08.763Z","%breezy_updated_date%":"2025-11-14T20:44:22.182Z","%_wpgmp_location_city%":"Tucson","%_wpgmp_location_state%":"AZ","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Tucson, AZ, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"32.2539787","%_wpgmp_metabox_longitude%":"-110.9741769","%rank_math_internal_links_processed%":"1"}},"id":2609,"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-11-14T20:41:18.866Z","%_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":2598,"infowindow_disable":false},{"source":"post","title":"Mine Superintendent","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Mine 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\/mine-superintendent\/\" name=\"Mine 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":"Midland-Odessa, TX, USA","location":{"lat":"31.8456816","city":"Midland-Odessa","state":"TX","country":"United States","lng":"-102.3676431","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/mine-superintendent\/","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<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.&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":"Mine Superintendent","post_link":"https:\/\/turnerstaffing.com\/position\/mine-superintendent\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Senior","%location_country%":"United States","%location_city%":"Midland-Odessa","%location_state_id%":"TX","%location_state_name%":"Texas","%location_city_state%":"Midland-Odessa, TX","%education%":"Unspecified","%department%":"Management","%description%":"<p><strong><u>Turner Mining Group - Project Superintendent<\/u><\/strong><br><\/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.&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%":"Management","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/1fc68b0ad11f-mine-superintendent","%breezy_id%":"1fc68b0ad11f","%breezy_friendly_id%":"1fc68b0ad11f-mine-superintendent","%breezy_created_date%":"2025-07-09T18:19:31.841Z","%breezy_updated_date%":"2025-11-14T20:43:13.143Z","%_wpgmp_location_city%":"Midland-Odessa","%_wpgmp_location_state%":"TX","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Midland-Odessa, TX, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"31.8456816","%_wpgmp_metabox_longitude%":"-102.3676431","%rank_math_internal_links_processed%":"1"}},"id":2592,"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: Montpelier, Virginia Position Type: Full-Time About Us: Turner Staffing Group,&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/heavy-equipment-operator-11\/\" 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: Montpelier, Virginia Position Type: Full-Time About Us: Turner Staffing Group,&hellip;","address":"Montpelier, VA, USA","location":{"lat":"37.8212538","city":"Montpelier","state":"VA","country":"United States","lng":"-77.6844344","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/heavy-equipment-operator-11\/","zoom":19,"extra_fields":{"post_excerpt":"Job Title: Heavy Equipment Operator Company: Turner Staffing Group Location: Montpelier, Virginia Position Type: Full-Time About Us: Turner Staffing Group,&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> Montpelier, Virginia<\/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 Montpelier, Virginia, 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-11\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Associate","%location_country%":"United States","%location_city%":"Montpelier","%location_state_id%":"VA","%location_state_name%":"Virginia","%location_city_state%":"Montpelier, VA","%education%":"Unspecified","%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> Montpelier, Virginia<\/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 Montpelier, Virginia, 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\/3b39cb35fdd2-heavy-equipment-operator","%breezy_id%":"3b39cb35fdd2","%breezy_friendly_id%":"3b39cb35fdd2-heavy-equipment-operator","%breezy_created_date%":"2025-06-26T20:34:37.909Z","%breezy_updated_date%":"2025-11-14T20:42:07.797Z","%_wpgmp_location_city%":"Montpelier","%_wpgmp_location_state%":"VA","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Montpelier, VA, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"37.8212538","%_wpgmp_metabox_longitude%":"-77.6844344","%rank_math_internal_links_processed%":"1"}},"id":2578,"infowindow_disable":false},{"source":"post","title":"Mining Electrician","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Mining Electrician\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    This role will carry out preventive and breakdown maintenance to fixed and mobile plant in an open cut environments. Duties&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/mining-electrician\/\" name=\"Mining Electrician\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"This role will carry out preventive and breakdown maintenance to fixed and mobile plant in an open cut environments. Duties&hellip;","address":"Wright, WY, USA","location":{"lat":"43.7518832","city":"Wright","state":"WY","country":"United States","lng":"-105.4913345","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/mining-electrician\/","zoom":19,"extra_fields":{"post_excerpt":"This role will carry out preventive and breakdown maintenance to fixed and mobile plant in an open cut environments. Duties&hellip;","post_content":"<p>This role will carry out preventive and breakdown maintenance to fixed and mobile plant in an open cut environments.<\/p>\n<p><\/p>\n<p>Duties will include:<\/p>\n<ul><li>Visibly support and champion our client's Mission and Values<\/li><li>Act in accordance with and adhere to Safety as a Way of Life Management System<\/li><\/ul>\n<ul><li>Inspect work area and plant for hazards, damage and defects<\/li><li>Examine drawings or specifications to determine work methods, sequence of activities or manufacture of components<\/li><li>Diagnose faults or breakdowns<\/li><li>Estimate time and materials required to complete jobs<\/li><li>Raise orders for materials<\/li><li>Undertake repairs or component changeouts as required<\/li><li>Clean and maintain tools and work area<\/li><li>Train other personnel or apprentices (if required)<\/li><li>Ensure activities comply with safety, environmental and statutory requirements<\/li><li>Other duties as assigned by the company<\/li><\/ul>\n<p><\/p>\n<p><strong>The Lifestyle:<\/strong><\/p>\n<p>This position may require the necessity to work weekends, holidays, or another shift as deemed necessary.&nbsp;&nbsp;&nbsp;<br><\/p>\n\n\n<p><\/p>\n<p><strong>About you:<\/strong><\/p>\n<ul><li>Three years\u2019 experience performing electrical maintenance work in a heavy industrial environment or mine site is preferred.<\/li><li>Ability to solve problems and troubleshoot situations arising in the pit area as needed.<\/li><li>Ability to work in all types of weather conditions and at different times of day.<\/li><li>Ability to work a flexible schedule as required by business need.<\/li><li>Ability to work rotating shifts, weekends and overtime when required.<\/li><li>High School Degree or GED Equivalent required<\/li><\/ul>\n<p><\/p>\n<p><strong>Physical Requirements - Surface:<\/strong><\/p>\n<ul><li>Must have the ability to stand for up to 4 hours per shift<\/li><li>Must have the ability to be seated for up to 4 hours to operate equipment or vehicles<\/li><li>Must have the ability to work from elevated positions, walk\/climb up and down stairs\/steps and climb on and off equipment and ladders<\/li><li>Must have the ability to wear required protective footwear, hearing and eye protection, and other personal protective equipment as required by Company and MSHA<\/li><li>Must have the ability to perform repetitive hand and wrist motions (push, pull, twist, handle), and have rapid reflex movements of the arms and legs and good hand to eye coordination<\/li><li>Must have the ability to lift\/raise 10 - 50 lbs. without mechanical assistance frequently during the course of work shift&nbsp;<\/li><li>Must have the ability to work in extreme conditions, including but not limited to changing weather conditions, dust, mud, varying levels of noise from low to high, varying degrees of light and dark, in and around artificial light and in a confined work area<\/li><li>The job requires that you be able to work various shifts (required shifts include days, evenings and nights with rotating schedules, weekends and holidays&nbsp;&nbsp;&nbsp;<\/li><\/ul>","post_title":"Mining Electrician","post_link":"https:\/\/turnerstaffing.com\/position\/mining-electrician\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Mid Level","%location_country%":"United States","%location_city%":"Wright","%location_state_id%":"WY","%location_state_name%":"Wyoming","%location_city_state%":"Wright, WY","%education%":"High School or equivalent","%department%":"","%description%":"<p>This role will carry out preventive and breakdown maintenance to fixed and mobile plant in an open cut environments.<\/p>\n<p><\/p>\n<p>Duties will include:<\/p>\n<ul><li>Visibly support and champion our client's Mission and Values<\/li><li>Act in accordance with and adhere to Safety as a Way of Life Management System<\/li><\/ul>\n<ul><li>Inspect work area and plant for hazards, damage and defects<\/li><li>Examine drawings or specifications to determine work methods, sequence of activities or manufacture of components<\/li><li>Diagnose faults or breakdowns<\/li><li>Estimate time and materials required to complete jobs<\/li><li>Raise orders for materials<\/li><li>Undertake repairs or component changeouts as required<\/li><li>Clean and maintain tools and work area<\/li><li>Train other personnel or apprentices (if required)<\/li><li>Ensure activities comply with safety, environmental and statutory requirements<\/li><li>Other duties as assigned by the company<\/li><\/ul>\n<p><\/p>\n<p><strong>The Lifestyle:<\/strong><\/p>\n<p>This position may require the necessity to work weekends, holidays, or another shift as deemed necessary.&nbsp;&nbsp;&nbsp;<br><\/p>\n\n\n<p><\/p>\n<p><strong>About you:<\/strong><\/p>\n<ul><li>Three years\u2019 experience performing electrical maintenance work in a heavy industrial environment or mine site is preferred.<\/li><li>Ability to solve problems and troubleshoot situations arising in the pit area as needed.<\/li><li>Ability to work in all types of weather conditions and at different times of day.<\/li><li>Ability to work a flexible schedule as required by business need.<\/li><li>Ability to work rotating shifts, weekends and overtime when required.<\/li><li>High School Degree or GED Equivalent required<\/li><\/ul>\n<p><\/p>\n<p><strong>Physical Requirements - Surface:<\/strong><\/p>\n<ul><li>Must have the ability to stand for up to 4 hours per shift<\/li><li>Must have the ability to be seated for up to 4 hours to operate equipment or vehicles<\/li><li>Must have the ability to work from elevated positions, walk\/climb up and down stairs\/steps and climb on and off equipment and ladders<\/li><li>Must have the ability to wear required protective footwear, hearing and eye protection, and other personal protective equipment as required by Company and MSHA<\/li><li>Must have the ability to perform repetitive hand and wrist motions (push, pull, twist, handle), and have rapid reflex movements of the arms and legs and good hand to eye coordination<\/li><li>Must have the ability to lift\/raise 10 - 50 lbs. without mechanical assistance frequently during the course of work shift&nbsp;<\/li><li>Must have the ability to work in extreme conditions, including but not limited to changing weather conditions, dust, mud, varying levels of noise from low to high, varying degrees of light and dark, in and around artificial light and in a confined work area<\/li><li>The job requires that you be able to work various shifts (required shifts include days, evenings and nights with rotating schedules, weekends and holidays&nbsp;&nbsp;&nbsp;<\/li><\/ul>","%category%":"Operations","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/a05737fef3a3-mining-electrician","%breezy_id%":"a05737fef3a3","%breezy_friendly_id%":"a05737fef3a3-mining-electrician","%breezy_created_date%":"2024-11-19T19:27:43.964Z","%breezy_updated_date%":"2025-11-14T20:44:46.846Z","%_wpgmp_location_city%":"Wright","%_wpgmp_location_state%":"WY","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Wright, WY, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"43.7518832","%_wpgmp_metabox_longitude%":"-105.4913345","%rank_math_internal_links_processed%":"1"}},"id":2573,"infowindow_disable":false},{"source":"post","title":"Mine Engineer","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Mine Engineer\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Job Details The Short Range Mining Engineer is responsible for developing and maintaining rolling mine plans spanning from monthly to&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/mine-engineer\/\" name=\"Mine Engineer\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Job Details The Short Range Mining Engineer is responsible for developing and maintaining rolling mine plans spanning from monthly to&hellip;","address":"Kearny, AZ, USA","location":{"lat":"33.0613504","city":"Kearny","state":"AZ","country":"United States","lng":"-110.9066589","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/mine-engineer\/","zoom":19,"extra_fields":{"post_excerpt":"Job Details The Short Range Mining Engineer is responsible for developing and maintaining rolling mine plans spanning from monthly to&hellip;","post_content":"<p>Job Details<\/p>\n<p>The Short Range Mining Engineer is responsible for developing and maintaining rolling mine plans spanning from monthly to a 12-month-plus horizon, with a focus on operational accuracy, geotechnical soundness, and production efficiency. Operating within an open pit copper mine that processes both sulfide and oxide ores with an autonomous haulage system (AHS) environment. This role translates mid-range planning objectives into detailed, AHS executable designs that guide daily production activities. Reporting directly to the Chief Mining Engineer, the Mining Engineer works cross-functionally with Geology, Survey, Operations, and AHS teams to generate practical bench layouts, material routing strategies, and shovel-ready instructions that support safe and continuous production. The ideal candidate will possess a strong understanding of mine planning systems, short-term sequencing, and field-level operational constraints, ensuring plans are both technically sound and AHS operationally executable. Rotation and cross-training with other mine planning roles is expected.<\/p>\n<p>Key Responsibilities:<\/p>\n<p>Develop and maintain a rolling short-range mine plan (1 to 12 months) that aligns with mid-range strategies, production goals, and operational constraints.<\/p>\n<p>Design and sequence pit advances, including bench layouts, dig polygons, ore control boundaries, and blast patterns, ensuring alignment with geotechnical, operational, and safety requirements.<\/p>\n<p>Design and coordinate closely with the Drill and Blast team to define burden, spacing, timing, and initiation designs that optimize fragmentation, minimize dilution, and reduce ore loss which are executable in an autonomous haulage system environment.<\/p>\n<p>Collaborate with Mine Geology to ensure accurate grade boundaries, reconciliation inputs, and material classification are incorporated into dig plans and routing instructions.<\/p>\n<p>Prepare detailed material movement plans, including routing of sulfide and oxide ores to crushers, leach pads, and stockpiles, ensuring delivery of the correct material type and blend.<\/p>\n<p>Generate shovel instructions, blast release maps, and haulage plans, and communicate these effectively to Mine Operations and AHS Controllers.<\/p>\n<p>Monitor plan execution, validate against survey pickups, and make timely adjustments for real-world conditions such as ground control issues, equipment availability, or changing priorities.<\/p>\n<p>Utilize Hexagon MinePlan 3D, Activity Scheduler, and haulage tools to model, visualize, and update mine plans and track performance against targets.<\/p>\n<p>Participate in daily and weekly operations meetings, reporting on short-term forecast accuracy, compliance, and corrective actions as needed.<\/p>\n<p>Contribute to the monthly forecast, budget updates, and production analysis by providing data-driven updates and reconciliation support.<\/p>\n<p>Work collaboratively and cross-train with Mid-Range and Long-Range Engineers to ensure planning continuity and feedback on plan execution.<\/p>\n<p>Maintain clear documentation of assumptions, changes, and plan decisions for operational transparency and continuous improvement.<\/p>\n<p>Requirements<\/p>\n<p>Qualifications:<\/p>\n<p>Bachelor\u2019s degree in Mining Engineering or related discipline<\/p>\n<p>Minimum 3-5 years of experience in open pit mine engineering or operations<\/p>\n<p>Experience in an autonomous haulage environment is a benefit<\/p>\n<p>Proficient in Hexagon MinePlan 3D, including Activity Scheduler, MPSO, and short-range design tools<\/p>\n<p>Strong understanding of open pit mining operations, drill and blast practices, ore control, and material logistics<\/p>\n<p>Ability to work in a fast-paced environment and interface effectively with field and technical teams<\/p>\n<p>Strong analytical, communication, and problem-solving skills<\/p>","post_title":"Mine Engineer","post_link":"https:\/\/turnerstaffing.com\/position\/mine-engineer\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"","%location_country%":"United States","%location_city%":"Kearny","%location_state_id%":"AZ","%location_state_name%":"Arizona","%location_city_state%":"Kearny, AZ","%education%":"","%department%":"","%description%":"<p>Job Details<\/p>\n<p>The Short Range Mining Engineer is responsible for developing and maintaining rolling mine plans spanning from monthly to a 12-month-plus horizon, with a focus on operational accuracy, geotechnical soundness, and production efficiency. Operating within an open pit copper mine that processes both sulfide and oxide ores with an autonomous haulage system (AHS) environment. This role translates mid-range planning objectives into detailed, AHS executable designs that guide daily production activities. Reporting directly to the Chief Mining Engineer, the Mining Engineer works cross-functionally with Geology, Survey, Operations, and AHS teams to generate practical bench layouts, material routing strategies, and shovel-ready instructions that support safe and continuous production. The ideal candidate will possess a strong understanding of mine planning systems, short-term sequencing, and field-level operational constraints, ensuring plans are both technically sound and AHS operationally executable. Rotation and cross-training with other mine planning roles is expected.<\/p>\n<p>Key Responsibilities:<\/p>\n<p>Develop and maintain a rolling short-range mine plan (1 to 12 months) that aligns with mid-range strategies, production goals, and operational constraints.<\/p>\n<p>Design and sequence pit advances, including bench layouts, dig polygons, ore control boundaries, and blast patterns, ensuring alignment with geotechnical, operational, and safety requirements.<\/p>\n<p>Design and coordinate closely with the Drill and Blast team to define burden, spacing, timing, and initiation designs that optimize fragmentation, minimize dilution, and reduce ore loss which are executable in an autonomous haulage system environment.<\/p>\n<p>Collaborate with Mine Geology to ensure accurate grade boundaries, reconciliation inputs, and material classification are incorporated into dig plans and routing instructions.<\/p>\n<p>Prepare detailed material movement plans, including routing of sulfide and oxide ores to crushers, leach pads, and stockpiles, ensuring delivery of the correct material type and blend.<\/p>\n<p>Generate shovel instructions, blast release maps, and haulage plans, and communicate these effectively to Mine Operations and AHS Controllers.<\/p>\n<p>Monitor plan execution, validate against survey pickups, and make timely adjustments for real-world conditions such as ground control issues, equipment availability, or changing priorities.<\/p>\n<p>Utilize Hexagon MinePlan 3D, Activity Scheduler, and haulage tools to model, visualize, and update mine plans and track performance against targets.<\/p>\n<p>Participate in daily and weekly operations meetings, reporting on short-term forecast accuracy, compliance, and corrective actions as needed.<\/p>\n<p>Contribute to the monthly forecast, budget updates, and production analysis by providing data-driven updates and reconciliation support.<\/p>\n<p>Work collaboratively and cross-train with Mid-Range and Long-Range Engineers to ensure planning continuity and feedback on plan execution.<\/p>\n<p>Maintain clear documentation of assumptions, changes, and plan decisions for operational transparency and continuous improvement.<\/p>\n<p>Requirements<\/p>\n<p>Qualifications:<\/p>\n<p>Bachelor\u2019s degree in Mining Engineering or related discipline<\/p>\n<p>Minimum 3-5 years of experience in open pit mine engineering or operations<\/p>\n<p>Experience in an autonomous haulage environment is a benefit<\/p>\n<p>Proficient in Hexagon MinePlan 3D, including Activity Scheduler, MPSO, and short-range design tools<\/p>\n<p>Strong understanding of open pit mining operations, drill and blast practices, ore control, and material logistics<\/p>\n<p>Ability to work in a fast-paced environment and interface effectively with field and technical teams<\/p>\n<p>Strong analytical, communication, and problem-solving skills<\/p>","%category%":"","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/fa92a9c7c3c4-mine-engineer","%breezy_id%":"fa92a9c7c3c4","%breezy_friendly_id%":"fa92a9c7c3c4-mine-engineer","%breezy_created_date%":"2025-06-19T21:21:11.281Z","%breezy_updated_date%":"2025-11-14T20:43:05.377Z","%_wpgmp_location_city%":"Kearny","%_wpgmp_location_state%":"AZ","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Kearny, AZ, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"33.0613504","%_wpgmp_metabox_longitude%":"-110.9066589","%rank_math_internal_links_processed%":"1"}},"id":2560,"infowindow_disable":false},{"source":"post","title":"Chief Mine Engineer","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Chief Mine Engineer\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    The Chief Mine Engineer is responsible for guiding, coordinating, and overseeing Short Range and Long Range Mine Planning. The Chief&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/chief-mine-engineer\/\" name=\"Chief Mine Engineer\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"The Chief Mine Engineer is responsible for guiding, coordinating, and overseeing Short Range and Long Range Mine Planning. The Chief&hellip;","address":"Tucson, AZ, USA","location":{"lat":"32.2539787","city":"Tucson","state":"AZ","country":"United States","lng":"-110.9741769","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/chief-mine-engineer\/","zoom":19,"extra_fields":{"post_excerpt":"The Chief Mine Engineer is responsible for guiding, coordinating, and overseeing Short Range and Long Range Mine Planning. The Chief&hellip;","post_content":"<p>The Chief Mine Engineer is responsible for guiding, coordinating, and overseeing Short Range and Long Range Mine Planning. The Chief Mine Engineer will maintain the quality of mine plans and schedules and monitor the operations' progress. The Senior Mine Engineer is responsible for coordinating and communicating mine plans with operations and other key stakeholders. The Senior Mine Engineer is responsible for evaluating trade-off studies and improving and optimizing Mine design. Must be a leader, and a mentor, willing to work in a fast-paced, dynamic environment, and apply sound engineering knowledge and skills to create solutions to operational challenges and maximize profit.<\/p>\n<p><\/p>\n<p><strong>Essential Functions:<\/strong><\/p>\n<ul><li>Lead the Mine Planning team in project development, fostering collaboration and optimizing resources to enhance productivity and safety.<\/li><li>Mentor and develop skills of other Technical Services staff members.<\/li><li>Develop strategic mine plans, including 5-year and Life of Mine plans.<\/li><li>Contribute and assist with Long-Range Planning, including pit optimization, mine scheduling, fleet sizing, dump designs, technical studies, and asset optimization.<\/li><li>Assist and mentor Short Range Planner to establish, execute, and effectively monitor weekly and monthly plans.<\/li><li>Actively participate in weekly planning meetings.<\/li><li>Evaluate methods to optimize ore extraction and mining sequence and prepare trade-off analyses as required.<\/li><li>Coordinate mine planning work with geology, dewatering, slope engineering, drill &amp; blast, and mine operations.<\/li><li>Troubleshoot problems that arise and frequently inspect open pit; analyze and recommend solutions.<\/li><li>Responsible for recognizing mine designs and fleet efficiency issues and implementing improvements to designs and efficiencies.<\/li><li>Analyze data and prepare technical memos or presentations to assist in the decision-making process.<\/li><li>Contribute to the development of policies and procedures in engineering.<\/li><li>Develop and manage annual budgets.<\/li><li>Track actual production and compare progress to the long- and short-range plans.<\/li><li>Assist with designing and implementing special projects.<\/li><li>Ensure engineering designs align with industry standards and best practices.<\/li><\/ul>\n<p><\/p>\n<p><strong>Additional Duties:<\/strong><\/p>\n<ul><li>Advanced knowledge of Hexagon MinePlan software packages.<\/li><li>Proficient in 3D mining software (Hexagon MinePlan, Whittle), fleet management systems (Modular Mining Dispatch, ProVision), and databases (acQuire, Access).<\/li><li>Must be able to manage time effectively and set priorities.<\/li><li>Strong leadership skills and ability to create a positive work environment.<\/li><li>Self-motivated and safety conscious.<\/li><li>Ability to prioritize multiple tasks and demonstratable project management skills.<\/li><li>Knowledge of MSHA and State, Environmental, and Safety regulations is beneficial.<\/li><li>Responsible for executing, supporting, and enforcing the Company's Environmental, Health, and Safety program as required by OIS policy, directives, and principles.<\/li><\/ul>\n<p>Requirements<\/p>\n<p><strong>Required Education and Experience:<\/strong><\/p>\n<ul><li>Requires seven (7) plus years of directly related open pit Mine Planning and Mine Operations Experience<\/li><li>A bachelor\u2019s degree in mining engineering or a related field.<\/li><\/ul>","post_title":"Chief Mine Engineer","post_link":"https:\/\/turnerstaffing.com\/position\/chief-mine-engineer\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"","%location_country%":"United States","%location_city%":"Tucson","%location_state_id%":"AZ","%location_state_name%":"Arizona","%location_city_state%":"Tucson, AZ","%education%":"","%department%":"","%description%":"<p>The Chief Mine Engineer is responsible for guiding, coordinating, and overseeing Short Range and Long Range Mine Planning. The Chief Mine Engineer will maintain the quality of mine plans and schedules and monitor the operations' progress. The Senior Mine Engineer is responsible for coordinating and communicating mine plans with operations and other key stakeholders. The Senior Mine Engineer is responsible for evaluating trade-off studies and improving and optimizing Mine design. Must be a leader, and a mentor, willing to work in a fast-paced, dynamic environment, and apply sound engineering knowledge and skills to create solutions to operational challenges and maximize profit.<\/p>\n<p><\/p>\n<p><strong>Essential Functions:<\/strong><\/p>\n<ul><li>Lead the Mine Planning team in project development, fostering collaboration and optimizing resources to enhance productivity and safety.<\/li><li>Mentor and develop skills of other Technical Services staff members.<\/li><li>Develop strategic mine plans, including 5-year and Life of Mine plans.<\/li><li>Contribute and assist with Long-Range Planning, including pit optimization, mine scheduling, fleet sizing, dump designs, technical studies, and asset optimization.<\/li><li>Assist and mentor Short Range Planner to establish, execute, and effectively monitor weekly and monthly plans.<\/li><li>Actively participate in weekly planning meetings.<\/li><li>Evaluate methods to optimize ore extraction and mining sequence and prepare trade-off analyses as required.<\/li><li>Coordinate mine planning work with geology, dewatering, slope engineering, drill &amp; blast, and mine operations.<\/li><li>Troubleshoot problems that arise and frequently inspect open pit; analyze and recommend solutions.<\/li><li>Responsible for recognizing mine designs and fleet efficiency issues and implementing improvements to designs and efficiencies.<\/li><li>Analyze data and prepare technical memos or presentations to assist in the decision-making process.<\/li><li>Contribute to the development of policies and procedures in engineering.<\/li><li>Develop and manage annual budgets.<\/li><li>Track actual production and compare progress to the long- and short-range plans.<\/li><li>Assist with designing and implementing special projects.<\/li><li>Ensure engineering designs align with industry standards and best practices.<\/li><\/ul>\n<p><\/p>\n<p><strong>Additional Duties:<\/strong><\/p>\n<ul><li>Advanced knowledge of Hexagon MinePlan software packages.<\/li><li>Proficient in 3D mining software (Hexagon MinePlan, Whittle), fleet management systems (Modular Mining Dispatch, ProVision), and databases (acQuire, Access).<\/li><li>Must be able to manage time effectively and set priorities.<\/li><li>Strong leadership skills and ability to create a positive work environment.<\/li><li>Self-motivated and safety conscious.<\/li><li>Ability to prioritize multiple tasks and demonstratable project management skills.<\/li><li>Knowledge of MSHA and State, Environmental, and Safety regulations is beneficial.<\/li><li>Responsible for executing, supporting, and enforcing the Company's Environmental, Health, and Safety program as required by OIS policy, directives, and principles.<\/li><\/ul>\n<p>Requirements<\/p>\n<p><strong>Required Education and Experience:<\/strong><\/p>\n<ul><li>Requires seven (7) plus years of directly related open pit Mine Planning and Mine Operations Experience<\/li><li>A bachelor\u2019s degree in mining engineering or a related field.<\/li><\/ul>","%category%":"","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/3beb2dade946-chief-mine-engineer","%breezy_id%":"3beb2dade946","%breezy_friendly_id%":"3beb2dade946-chief-mine-engineer","%breezy_created_date%":"2025-06-18T15:04:19.824Z","%breezy_updated_date%":"2025-11-14T20:40:21.908Z","%_wpgmp_location_city%":"Tucson","%_wpgmp_location_state%":"AZ","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Tucson, AZ, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"32.2539787","%_wpgmp_metabox_longitude%":"-110.9741769","%rank_math_internal_links_processed%":"1"}},"id":2547,"infowindow_disable":false},{"source":"post","title":"Welder\/Mechanic","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Welder\/Mechanic\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Job Summary\/Essential Functions: \u2022 . Inspect, trouble shoot, and perform the required welding on all equipment at the jobsite, \u2022&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/welder-mechanic-4\/\" name=\"Welder\/Mechanic\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Job Summary\/Essential Functions: \u2022 . Inspect, trouble shoot, and perform the required welding on all equipment at the jobsite, \u2022&hellip;","address":"Bedford, IN, USA","location":{"lat":"38.8611619","city":"Bedford","state":"IN","country":"United States","lng":"-86.4872149","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/welder-mechanic-4\/","zoom":19,"extra_fields":{"post_excerpt":"Job Summary\/Essential Functions: \u2022 . Inspect, trouble shoot, and perform the required welding on all equipment at the jobsite, \u2022&hellip;","post_content":"<p>Job Summary\/Essential Functions:<\/p>\n<p>\u2022 . Inspect, trouble shoot, and perform the required welding on all equipment at the jobsite,<\/p>\n<p>\u2022 . Perform preventive maintenance and catastrophic failure repair.<\/p>\n<p>\u2022 Fuel and grease equipment when required.<\/p>\n<p>\u2022 Keep records of work performed.<\/p>\n<p>Special skills or Qualifications Required:<\/p>\n<p>. \u2022 Must have at least one year of experience in welding and repair of heavy diesel equipment and experience in hard surfacing and repair of ground engaging tools.<\/p>\n<p>\u2022 Must have the ability to do the following:<\/p>\n<p>- Weld in all positions (horizontal, vertical and overhead).<\/p>\n<p>- Properly use a torch, air arc, stick weld, and wire weld.<\/p>\n<p>- Have a working knowledge of MIG and TIG units and the different types of metals associated with mining equipment.<\/p>\n<p>\u2022 Must have at least one year of experience align boring and re-facing.<\/p>\n<p>\u2022 \u2022 . Must have basic math skills.<\/p>\n<p>\u2022 Must possess a valid driver's license.<\/p>\n<p>\u2022 Must possess a high school diploma or GED.<\/p>\n<p>Expectations:<\/p>\n<p>\u2022 Must be self-motivated and able to work with minimal supervision.<\/p>\n<p>\u2022 Must be able to communicate and coordinate with co-workers and supervisors.<\/p>\n<p>\u2022 Must follow Company, State and Federal regulations, plans and policies.<\/p>\n<p>\u2022 Must have high safety standards for self and others and wear required personal protective equipment.<\/p>\n<p>\u2022\u2022 Must be able to read &amp; understand Material Safety Data Sheets and be able to operate power tools, hand tools, etc.<\/p>\n<p>\u2022 Must be willing to work any assigned shift, overtime, weekends and holidays.<\/p>\n<p>Physical Requirements, Surface Operations:<\/p>\n<p>\u2022 Perform constant functions including walking, standing, travel up and down stairs and vertical ladders, working overhead, bending f01ward and twisting<\/p>\n<p>\u2022 Must have the ability to stand and squat without support for prolonged periods of time.<\/p>\n<p>, \u2022 Must have the ability to be seated for up to 4 hours to operate equipment or vehicles.<\/p>\n<p>\u2022 Must have the ability to work from elevated positions, walk\/climb up and down stairs\/steps and climb on and off equipment and ladders (ascend\/ descend 14' ve1iical ladder).<\/p>\n<p>\u2022 Must have the ability to lift\/raise 10 - 50 lbs, without mechanical assistance frequently during the course of work shift.<\/p>\n<p>\u2022 Must be able to cany box, 2-handed, 50ft with a load of 50lbs.<\/p>\n<p>\u2022 Must be able to lift box, 2-handed, Floor to Shoulder with a load of 50lbs.<\/p>\n<p>\u2022 Must be able to lift box, 2-handed, 17\" to 36\" with a load of 501bs.,<\/p>\n<p>\u2022 Must be able to work overhead with a load of 5lbs in each hand,<\/p>\n<p>\u2022 Must have adequate balance to safely work on 6\" wide beams.<\/p>\n<p>\u2022 Must have the ability to perform repetitive hand and wrist motions (push, pull, twist, handle), and have rapid reflex movements of the arms and legs and good hand.to eye coordination.<\/p>\n<p>\u2022 Must have the ability to work in extreme conditions, including but not limited to changing weather conditions, dust, mud, varying levels of noise from low to high, varying degrees of light and dark, in and around artificial light, hot work environments and in a MSHA recognized confined work area.<\/p>\n<p>\u2022 Must be able to work with\/in equipment with moderate to high levels of vibration.<\/p>\n<p>\u2022 Must have the ability to wear required protective footwear, hearing and eye protection, and other personal protective equipment as required by Company and MSHA.<\/p>","post_title":"Welder\/Mechanic","post_link":"https:\/\/turnerstaffing.com\/position\/welder-mechanic-4\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"","%location_country%":"United States","%location_city%":"Bedford","%location_state_id%":"IN","%location_state_name%":"Indiana","%location_city_state%":"Bedford, IN","%education%":"","%department%":"","%description%":"<p>Job Summary\/Essential Functions:<\/p>\n<p>\u2022 . Inspect, trouble shoot, and perform the required welding on all equipment at the jobsite,<\/p>\n<p>\u2022 . Perform preventive maintenance and catastrophic failure repair.<\/p>\n<p>\u2022 Fuel and grease equipment when required.<\/p>\n<p>\u2022 Keep records of work performed.<\/p>\n<p>Special skills or Qualifications Required:<\/p>\n<p>. \u2022 Must have at least one year of experience in welding and repair of heavy diesel equipment and experience in hard surfacing and repair of ground engaging tools.<\/p>\n<p>\u2022 Must have the ability to do the following:<\/p>\n<p>- Weld in all positions (horizontal, vertical and overhead).<\/p>\n<p>- Properly use a torch, air arc, stick weld, and wire weld.<\/p>\n<p>- Have a working knowledge of MIG and TIG units and the different types of metals associated with mining equipment.<\/p>\n<p>\u2022 Must have at least one year of experience align boring and re-facing.<\/p>\n<p>\u2022 \u2022 . Must have basic math skills.<\/p>\n<p>\u2022 Must possess a valid driver's license.<\/p>\n<p>\u2022 Must possess a high school diploma or GED.<\/p>\n<p>Expectations:<\/p>\n<p>\u2022 Must be self-motivated and able to work with minimal supervision.<\/p>\n<p>\u2022 Must be able to communicate and coordinate with co-workers and supervisors.<\/p>\n<p>\u2022 Must follow Company, State and Federal regulations, plans and policies.<\/p>\n<p>\u2022 Must have high safety standards for self and others and wear required personal protective equipment.<\/p>\n<p>\u2022\u2022 Must be able to read &amp; understand Material Safety Data Sheets and be able to operate power tools, hand tools, etc.<\/p>\n<p>\u2022 Must be willing to work any assigned shift, overtime, weekends and holidays.<\/p>\n<p>Physical Requirements, Surface Operations:<\/p>\n<p>\u2022 Perform constant functions including walking, standing, travel up and down stairs and vertical ladders, working overhead, bending f01ward and twisting<\/p>\n<p>\u2022 Must have the ability to stand and squat without support for prolonged periods of time.<\/p>\n<p>, \u2022 Must have the ability to be seated for up to 4 hours to operate equipment or vehicles.<\/p>\n<p>\u2022 Must have the ability to work from elevated positions, walk\/climb up and down stairs\/steps and climb on and off equipment and ladders (ascend\/ descend 14' ve1iical ladder).<\/p>\n<p>\u2022 Must have the ability to lift\/raise 10 - 50 lbs, without mechanical assistance frequently during the course of work shift.<\/p>\n<p>\u2022 Must be able to cany box, 2-handed, 50ft with a load of 50lbs.<\/p>\n<p>\u2022 Must be able to lift box, 2-handed, Floor to Shoulder with a load of 50lbs.<\/p>\n<p>\u2022 Must be able to lift box, 2-handed, 17\" to 36\" with a load of 501bs.,<\/p>\n<p>\u2022 Must be able to work overhead with a load of 5lbs in each hand,<\/p>\n<p>\u2022 Must have adequate balance to safely work on 6\" wide beams.<\/p>\n<p>\u2022 Must have the ability to perform repetitive hand and wrist motions (push, pull, twist, handle), and have rapid reflex movements of the arms and legs and good hand.to eye coordination.<\/p>\n<p>\u2022 Must have the ability to work in extreme conditions, including but not limited to changing weather conditions, dust, mud, varying levels of noise from low to high, varying degrees of light and dark, in and around artificial light, hot work environments and in a MSHA recognized confined work area.<\/p>\n<p>\u2022 Must be able to work with\/in equipment with moderate to high levels of vibration.<\/p>\n<p>\u2022 Must have the ability to wear required protective footwear, hearing and eye protection, and other personal protective equipment as required by Company and MSHA.<\/p>","%category%":"Operations","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/63abcaa8253d-welder-mechanic","%breezy_id%":"63abcaa8253d","%breezy_friendly_id%":"63abcaa8253d-welder-mechanic","%breezy_created_date%":"2025-06-16T14:49:41.490Z","%breezy_updated_date%":"2025-11-14T20:44:30.240Z","%_wpgmp_location_city%":"Bedford","%_wpgmp_location_state%":"IN","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Bedford, IN, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"38.8611619","%_wpgmp_metabox_longitude%":"-86.4872149","%rank_math_internal_links_processed%":"1"}},"id":2543,"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 Staffing 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-4\/\" name=\"Haul Truck Driver\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Turner Staffing Group \u2013 Haul Truck Driver Do you love mining? Do you think differently? Are you ready to define&hellip;","address":"Terre Haute, IN, USA","location":{"lat":"39.4654441","city":"Terre Haute","state":"IN","country":"United States","lng":"-87.4139427","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/haul-truck-driver-4\/","zoom":19,"extra_fields":{"post_excerpt":"Turner Staffing 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 Staffing 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 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 mining Haul Truck Drivers for our fast-growing, forward thinking mining services company for a long term opportunity near Vincennes, IN.<\/p>\n<p>Turner Staffing 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 Staffing 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><br><\/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>","post_title":"Haul Truck Driver","post_link":"https:\/\/turnerstaffing.com\/position\/haul-truck-driver-4\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Associate","%location_country%":"United States","%location_city%":"Terre Haute","%location_state_id%":"IN","%location_state_name%":"Indiana","%location_city_state%":"Terre Haute, IN","%education%":"Unspecified","%department%":"","%description%":"<p><strong><u>Turner Staffing 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 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 mining Haul Truck Drivers for our fast-growing, forward thinking mining services company for a long term opportunity near Vincennes, IN.<\/p>\n<p>Turner Staffing 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 Staffing 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><br><\/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>","%category%":"Operations","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/6a713fc979af-haul-truck-driver","%breezy_id%":"6a713fc979af","%breezy_friendly_id%":"6a713fc979af-haul-truck-driver","%breezy_created_date%":"2025-06-12T19:31:33.423Z","%breezy_updated_date%":"2026-01-20T15:19:32.033Z","%_wpgmp_location_city%":"Terre Haute","%_wpgmp_location_state%":"IN","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Terre Haute, IN, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"39.4654441","%_wpgmp_metabox_longitude%":"-87.4139427","%rank_math_internal_links_processed%":"1"}},"id":2539,"infowindow_disable":false},{"source":"post","title":"Welder\/Mechanic","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Welder\/Mechanic\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Job Summary\/Essential Functions: \u2022 . Inspect, trouble shoot, and perform the required welding on all equipment at the jobsite, \u2022&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/welder-mechanic-3\/\" name=\"Welder\/Mechanic\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Job Summary\/Essential Functions: \u2022 . Inspect, trouble shoot, and perform the required welding on all equipment at the jobsite, \u2022&hellip;","address":"Vincennes, IN, USA","location":{"lat":"38.677269","city":"Vincennes","state":"IN","country":"United States","lng":"-87.5286325","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/welder-mechanic-3\/","zoom":19,"extra_fields":{"post_excerpt":"Job Summary\/Essential Functions: \u2022 . Inspect, trouble shoot, and perform the required welding on all equipment at the jobsite, \u2022&hellip;","post_content":"<p>Job Summary\/Essential Functions: <\/p>\n<p>\u2022\t. Inspect, trouble shoot, and perform the required welding on all equipment at the jobsite,<\/p>\n<p>\u2022\t. Perform preventive maintenance and catastrophic failure repair.<\/p>\n<p>\u2022\tFuel and grease equipment when required.<\/p>\n<p>\u2022\tKeep records of work performed.<\/p>\n<p>Special skills or Qualifications Required:<\/p>\n<p>. \u2022\t\tMust have at least one year of experience in welding and repair of heavy diesel equipment and experience in hard surfacing and repair of ground engaging tools.<\/p>\n<p>\u2022\tMust have the ability to do the following:<\/p>\n<p>-\tWeld in all positions (horizontal, vertical and overhead).<\/p>\n<p>-\tProperly use a torch, air arc, stick weld, and wire weld.<\/p>\n<p>-\tHave a working knowledge of MIG and TIG units and the different types of metals associated with mining equipment.<\/p>\n<p>\u2022\tMust have at least one year of experience align boring and re-facing.<\/p>\n<p>\u2022\t\u2022\t. Must have basic math skills.<\/p>\n<p>\u2022\tMust possess a valid driver's license.<\/p>\n<p>\u2022\tMust possess a high school diploma or GED.<\/p>\n<p>Expectations:<\/p>\n<p>\u2022\tMust be self-motivated and able to work with minimal supervision.<\/p>\n<p>\u2022\tMust be able to communicate and coordinate with co-workers and supervisors.<\/p>\n<p>\u2022\tMust follow Company, State and Federal regulations, plans and policies.<\/p>\n<p>\u2022\tMust have high safety standards for self and others and wear required personal protective equipment.<\/p>\n<p>\u2022\u2022\tMust be able to read &amp; understand Material Safety Data Sheets and be able to operate power tools, hand tools, etc.<\/p>\n<p>\u2022\tMust be willing to work any assigned shift, overtime, weekends and holidays.<\/p>\n<p>Physical Requirements, Surface Operations:<\/p>\n<p>\u2022\tPerform constant functions including walking, standing, travel up and down stairs and vertical ladders, working overhead, bending f01ward and twisting<\/p>\n<p>\u2022\tMust have the ability to stand and squat without support for prolonged periods of time.<\/p>\n<p>,\t\u2022\tMust have the ability to be seated for up to 4 hours to operate equipment or vehicles.<\/p>\n<p>\u2022\tMust have the ability to work from elevated positions, walk\/climb up and down stairs\/steps and climb on and off equipment and ladders (ascend\/ descend 14' ve1iical ladder).<\/p>\n<p>\u2022\tMust have the ability to lift\/raise 10 - 50 lbs, without mechanical assistance frequently during the course of work shift.<\/p>\n<p>\u2022\tMust be able to cany box, 2-handed, 50ft with a load of 50lbs.<\/p>\n<p>\u2022\tMust be able to lift box, 2-handed, Floor to Shoulder with a load of 50lbs.<\/p>\n<p>\u2022\tMust be able to lift box, 2-handed, 17\" to 36\" with a load of 501bs.,<\/p>\n<p>\u2022\tMust be able to work overhead with a load of 5lbs in each hand,<\/p>\n<p>\u2022\tMust have adequate balance to safely work on 6\" wide beams.<\/p>\n<p>\u2022\tMust have the ability to perform repetitive hand and wrist motions (push, pull, twist, handle), and have rapid reflex movements of the arms and legs and good hand.to eye coordination.<\/p>\n<p>\u2022\tMust have the ability to work in extreme conditions, including but not limited to changing weather conditions, dust, mud, varying levels of noise from low to high, varying degrees of light and dark, in and around artificial light, hot work environments and in a MSHA recognized confined work area.<\/p>\n<p>\u2022\tMust be able to work with\/in equipment with moderate to high levels of vibration.<\/p>\n<p>\u2022\tMust have the ability to wear required protective footwear, hearing and eye protection, and other personal protective equipment as required by Company and MSHA.<\/p>","post_title":"Welder\/Mechanic","post_link":"https:\/\/turnerstaffing.com\/position\/welder-mechanic-3\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Mid Level","%location_country%":"United States","%location_city%":"Vincennes","%location_state_id%":"IN","%location_state_name%":"Indiana","%location_city_state%":"Vincennes, IN","%education%":"Unspecified","%department%":"","%description%":"<p>Job Summary\/Essential Functions: <\/p>\n<p>\u2022\t. Inspect, trouble shoot, and perform the required welding on all equipment at the jobsite,<\/p>\n<p>\u2022\t. Perform preventive maintenance and catastrophic failure repair.<\/p>\n<p>\u2022\tFuel and grease equipment when required.<\/p>\n<p>\u2022\tKeep records of work performed.<\/p>\n<p>Special skills or Qualifications Required:<\/p>\n<p>. \u2022\t\tMust have at least one year of experience in welding and repair of heavy diesel equipment and experience in hard surfacing and repair of ground engaging tools.<\/p>\n<p>\u2022\tMust have the ability to do the following:<\/p>\n<p>-\tWeld in all positions (horizontal, vertical and overhead).<\/p>\n<p>-\tProperly use a torch, air arc, stick weld, and wire weld.<\/p>\n<p>-\tHave a working knowledge of MIG and TIG units and the different types of metals associated with mining equipment.<\/p>\n<p>\u2022\tMust have at least one year of experience align boring and re-facing.<\/p>\n<p>\u2022\t\u2022\t. Must have basic math skills.<\/p>\n<p>\u2022\tMust possess a valid driver's license.<\/p>\n<p>\u2022\tMust possess a high school diploma or GED.<\/p>\n<p>Expectations:<\/p>\n<p>\u2022\tMust be self-motivated and able to work with minimal supervision.<\/p>\n<p>\u2022\tMust be able to communicate and coordinate with co-workers and supervisors.<\/p>\n<p>\u2022\tMust follow Company, State and Federal regulations, plans and policies.<\/p>\n<p>\u2022\tMust have high safety standards for self and others and wear required personal protective equipment.<\/p>\n<p>\u2022\u2022\tMust be able to read &amp; understand Material Safety Data Sheets and be able to operate power tools, hand tools, etc.<\/p>\n<p>\u2022\tMust be willing to work any assigned shift, overtime, weekends and holidays.<\/p>\n<p>Physical Requirements, Surface Operations:<\/p>\n<p>\u2022\tPerform constant functions including walking, standing, travel up and down stairs and vertical ladders, working overhead, bending f01ward and twisting<\/p>\n<p>\u2022\tMust have the ability to stand and squat without support for prolonged periods of time.<\/p>\n<p>,\t\u2022\tMust have the ability to be seated for up to 4 hours to operate equipment or vehicles.<\/p>\n<p>\u2022\tMust have the ability to work from elevated positions, walk\/climb up and down stairs\/steps and climb on and off equipment and ladders (ascend\/ descend 14' ve1iical ladder).<\/p>\n<p>\u2022\tMust have the ability to lift\/raise 10 - 50 lbs, without mechanical assistance frequently during the course of work shift.<\/p>\n<p>\u2022\tMust be able to cany box, 2-handed, 50ft with a load of 50lbs.<\/p>\n<p>\u2022\tMust be able to lift box, 2-handed, Floor to Shoulder with a load of 50lbs.<\/p>\n<p>\u2022\tMust be able to lift box, 2-handed, 17\" to 36\" with a load of 501bs.,<\/p>\n<p>\u2022\tMust be able to work overhead with a load of 5lbs in each hand,<\/p>\n<p>\u2022\tMust have adequate balance to safely work on 6\" wide beams.<\/p>\n<p>\u2022\tMust have the ability to perform repetitive hand and wrist motions (push, pull, twist, handle), and have rapid reflex movements of the arms and legs and good hand.to eye coordination.<\/p>\n<p>\u2022\tMust have the ability to work in extreme conditions, including but not limited to changing weather conditions, dust, mud, varying levels of noise from low to high, varying degrees of light and dark, in and around artificial light, hot work environments and in a MSHA recognized confined work area.<\/p>\n<p>\u2022\tMust be able to work with\/in equipment with moderate to high levels of vibration.<\/p>\n<p>\u2022\tMust have the ability to wear required protective footwear, hearing and eye protection, and other personal protective equipment as required by Company and MSHA.<\/p>","%category%":"Operations","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/e4dd19e1bf23-welder-mechanic","%breezy_id%":"e4dd19e1bf23","%breezy_friendly_id%":"e4dd19e1bf23-welder-mechanic","%breezy_created_date%":"2025-06-10T16:36:32.841Z","%breezy_updated_date%":"2025-11-14T20:44:28.903Z","%_wpgmp_location_city%":"Vincennes","%_wpgmp_location_state%":"IN","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Vincennes, IN, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"38.677269","%_wpgmp_metabox_longitude%":"-87.5286325","%rank_math_internal_links_processed%":"1"}},"id":2527,"infowindow_disable":false},{"source":"post","title":"Welder\/Mechanic","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Welder\/Mechanic\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Job Summary\/Essential Functions: \u2022 . Inspect, trouble shoot, and perform the required welding on all equipment at the jobsite, \u2022&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/welder-mechanic-2\/\" name=\"Welder\/Mechanic\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Job Summary\/Essential Functions: \u2022 . Inspect, trouble shoot, and perform the required welding on all equipment at the jobsite, \u2022&hellip;","address":"Linton, IN, USA","location":{"lat":"39.0347666","city":"Linton","state":"IN","country":"United States","lng":"-87.1658458","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/welder-mechanic-2\/","zoom":19,"extra_fields":{"post_excerpt":"Job Summary\/Essential Functions: \u2022 . Inspect, trouble shoot, and perform the required welding on all equipment at the jobsite, \u2022&hellip;","post_content":"<p>Job Summary\/Essential Functions: <\/p>\n<p>\u2022\t. Inspect, trouble shoot, and perform the required welding on all equipment at the jobsite,<\/p>\n<p>\u2022\t. Perform preventive maintenance and catastrophic failure repair.<\/p>\n<p>\u2022\tFuel and grease equipment when required.<\/p>\n<p>\u2022\tKeep records of work performed.<\/p>\n<p>Special skills or Qualifications Required:<\/p>\n<p>. \u2022\t\tMust have at least one year of experience in welding and repair of heavy diesel equipment and experience in hard surfacing and repair of ground engaging tools.<\/p>\n<p>\u2022\tMust have the ability to do the following:<\/p>\n<p>-\tWeld in all positions (horizontal, vertical and overhead).<\/p>\n<p>-\tProperly use a torch, air arc, stick weld, and wire weld.<\/p>\n<p>-\tHave a working knowledge of MIG and TIG units and the different types of metals associated with mining equipment.<\/p>\n<p>\u2022\tMust have at least one year of experience align boring and re-facing.<\/p>\n<p>\u2022\t\u2022\t. Must have basic math skills.<\/p>\n<p>\u2022\tMust possess a valid driver's license.<\/p>\n<p>\u2022\tMust possess a high school diploma or GED.<\/p>\n<p>Expectations:<\/p>\n<p>\u2022\tMust be self-motivated and able to work with minimal supervision.<\/p>\n<p>\u2022\tMust be able to communicate and coordinate with co-workers and supervisors.<\/p>\n<p>\u2022\tMust follow Company, State and Federal regulations, plans and policies.<\/p>\n<p>\u2022\tMust have high safety standards for self and others and wear required personal protective equipment.<\/p>\n<p>\u2022\u2022\tMust be able to read &amp; understand Material Safety Data Sheets and be able to operate power tools, hand tools, etc.<\/p>\n<p>\u2022\tMust be willing to work any assigned shift, overtime, weekends and holidays.<\/p>\n<p>Physical Requirements, Surface Operations:<\/p>\n<p>\u2022\tPerform constant functions including walking, standing, travel up and down stairs and vertical ladders, working overhead, bending f01ward and twisting<\/p>\n<p>\u2022\tMust have the ability to stand and squat without support for prolonged periods of time.<\/p>\n<p>,\t\u2022\tMust have the ability to be seated for up to 4 hours to operate equipment or vehicles.<\/p>\n<p>\u2022\tMust have the ability to work from elevated positions, walk\/climb up and down stairs\/steps and climb on and off equipment and ladders (ascend\/ descend 14' ve1iical ladder).<\/p>\n<p>\u2022\tMust have the ability to lift\/raise 10 - 50 lbs, without mechanical assistance frequently during the course of work shift.<\/p>\n<p>\u2022\tMust be able to cany box, 2-handed, 50ft with a load of 50lbs.<\/p>\n<p>\u2022\tMust be able to lift box, 2-handed, Floor to Shoulder with a load of 50lbs.<\/p>\n<p>\u2022\tMust be able to lift box, 2-handed, 17\" to 36\" with a load of 501bs.,<\/p>\n<p>\u2022\tMust be able to work overhead with a load of 5lbs in each hand,<\/p>\n<p>\u2022\tMust have adequate balance to safely work on 6\" wide beams.<\/p>\n<p>\u2022\tMust have the ability to perform repetitive hand and wrist motions (push, pull, twist, handle), and have rapid reflex movements of the arms and legs and good hand.to eye coordination.<\/p>\n<p>\u2022\tMust have the ability to work in extreme conditions, including but not limited to changing weather conditions, dust, mud, varying levels of noise from low to high, varying degrees of light and dark, in and around artificial light, hot work environments and in a MSHA recognized confined work area.<\/p>\n<p>\u2022\tMust be able to work with\/in equipment with moderate to high levels of vibration.<\/p>\n<p>\u2022\tMust have the ability to wear required protective footwear, hearing and eye protection, and other personal protective equipment as required by Company and MSHA.<\/p>","post_title":"Welder\/Mechanic","post_link":"https:\/\/turnerstaffing.com\/position\/welder-mechanic-2\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Mid Level","%location_country%":"United States","%location_city%":"Linton","%location_state_id%":"IN","%location_state_name%":"Indiana","%location_city_state%":"Linton, IN","%education%":"Unspecified","%department%":"","%description%":"<p>Job Summary\/Essential Functions: <\/p>\n<p>\u2022\t. Inspect, trouble shoot, and perform the required welding on all equipment at the jobsite,<\/p>\n<p>\u2022\t. Perform preventive maintenance and catastrophic failure repair.<\/p>\n<p>\u2022\tFuel and grease equipment when required.<\/p>\n<p>\u2022\tKeep records of work performed.<\/p>\n<p>Special skills or Qualifications Required:<\/p>\n<p>. \u2022\t\tMust have at least one year of experience in welding and repair of heavy diesel equipment and experience in hard surfacing and repair of ground engaging tools.<\/p>\n<p>\u2022\tMust have the ability to do the following:<\/p>\n<p>-\tWeld in all positions (horizontal, vertical and overhead).<\/p>\n<p>-\tProperly use a torch, air arc, stick weld, and wire weld.<\/p>\n<p>-\tHave a working knowledge of MIG and TIG units and the different types of metals associated with mining equipment.<\/p>\n<p>\u2022\tMust have at least one year of experience align boring and re-facing.<\/p>\n<p>\u2022\t\u2022\t. Must have basic math skills.<\/p>\n<p>\u2022\tMust possess a valid driver's license.<\/p>\n<p>\u2022\tMust possess a high school diploma or GED.<\/p>\n<p>Expectations:<\/p>\n<p>\u2022\tMust be self-motivated and able to work with minimal supervision.<\/p>\n<p>\u2022\tMust be able to communicate and coordinate with co-workers and supervisors.<\/p>\n<p>\u2022\tMust follow Company, State and Federal regulations, plans and policies.<\/p>\n<p>\u2022\tMust have high safety standards for self and others and wear required personal protective equipment.<\/p>\n<p>\u2022\u2022\tMust be able to read &amp; understand Material Safety Data Sheets and be able to operate power tools, hand tools, etc.<\/p>\n<p>\u2022\tMust be willing to work any assigned shift, overtime, weekends and holidays.<\/p>\n<p>Physical Requirements, Surface Operations:<\/p>\n<p>\u2022\tPerform constant functions including walking, standing, travel up and down stairs and vertical ladders, working overhead, bending f01ward and twisting<\/p>\n<p>\u2022\tMust have the ability to stand and squat without support for prolonged periods of time.<\/p>\n<p>,\t\u2022\tMust have the ability to be seated for up to 4 hours to operate equipment or vehicles.<\/p>\n<p>\u2022\tMust have the ability to work from elevated positions, walk\/climb up and down stairs\/steps and climb on and off equipment and ladders (ascend\/ descend 14' ve1iical ladder).<\/p>\n<p>\u2022\tMust have the ability to lift\/raise 10 - 50 lbs, without mechanical assistance frequently during the course of work shift.<\/p>\n<p>\u2022\tMust be able to cany box, 2-handed, 50ft with a load of 50lbs.<\/p>\n<p>\u2022\tMust be able to lift box, 2-handed, Floor to Shoulder with a load of 50lbs.<\/p>\n<p>\u2022\tMust be able to lift box, 2-handed, 17\" to 36\" with a load of 501bs.,<\/p>\n<p>\u2022\tMust be able to work overhead with a load of 5lbs in each hand,<\/p>\n<p>\u2022\tMust have adequate balance to safely work on 6\" wide beams.<\/p>\n<p>\u2022\tMust have the ability to perform repetitive hand and wrist motions (push, pull, twist, handle), and have rapid reflex movements of the arms and legs and good hand.to eye coordination.<\/p>\n<p>\u2022\tMust have the ability to work in extreme conditions, including but not limited to changing weather conditions, dust, mud, varying levels of noise from low to high, varying degrees of light and dark, in and around artificial light, hot work environments and in a MSHA recognized confined work area.<\/p>\n<p>\u2022\tMust be able to work with\/in equipment with moderate to high levels of vibration.<\/p>\n<p>\u2022\tMust have the ability to wear required protective footwear, hearing and eye protection, and other personal protective equipment as required by Company and MSHA.<\/p>","%category%":"Operations","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/b48e7bc578a2-welder-mechanic","%breezy_id%":"b48e7bc578a2","%breezy_friendly_id%":"b48e7bc578a2-welder-mechanic","%breezy_created_date%":"2025-06-10T16:35:47.451Z","%breezy_updated_date%":"2025-11-14T20:44:27.553Z","%_wpgmp_location_city%":"Linton","%_wpgmp_location_state%":"IN","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Linton, IN, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"39.0347666","%_wpgmp_metabox_longitude%":"-87.1658458","%rank_math_internal_links_processed%":"1"}},"id":2526,"infowindow_disable":false},{"source":"post","title":"Welder\/Mechanic","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Welder\/Mechanic\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Job Summary\/Essential Functions: \u2022 . Inspect, trouble shoot, and perform the required welding on all equipment at the jobsite, \u2022&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/welder-mechanic\/\" name=\"Welder\/Mechanic\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Job Summary\/Essential Functions: \u2022 . Inspect, trouble shoot, and perform the required welding on all equipment at the jobsite, \u2022&hellip;","address":"Carlisle, IN, USA","location":{"lat":"38.9623034","city":"Carlisle","state":"IN","country":"United States","lng":"-87.4025572","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/welder-mechanic\/","zoom":19,"extra_fields":{"post_excerpt":"Job Summary\/Essential Functions: \u2022 . Inspect, trouble shoot, and perform the required welding on all equipment at the jobsite, \u2022&hellip;","post_content":"<p>Job Summary\/Essential Functions: <\/p>\n<p>\u2022\t. Inspect, trouble shoot, and perform the required welding on all equipment at the jobsite,<\/p>\n<p>\u2022\t. Perform preventive maintenance and catastrophic failure repair.<\/p>\n<p>\u2022\tFuel and grease equipment when required.<\/p>\n<p>\u2022\tKeep records of work performed.<\/p>\n<p>Special skills or Qualifications Required:<\/p>\n<p>. \u2022\t\tMust have at least one year of experience in welding and repair of heavy diesel equipment and experience in hard surfacing and repair of ground engaging tools.<\/p>\n<p>\u2022\tMust have the ability to do the following:<\/p>\n<p>-\tWeld in all positions (horizontal, vertical and overhead).<\/p>\n<p>-\tProperly use a torch, air arc, stick weld, and wire weld.<\/p>\n<p>-\tHave a working knowledge of MIG and TIG units and the different types of metals associated with mining equipment.<\/p>\n<p>\u2022\tMust have at least one year of experience align boring and re-facing.<\/p>\n<p>\u2022\t\u2022\t. Must have basic math skills.<\/p>\n<p>\u2022\tMust possess a valid driver's license.<\/p>\n<p>\u2022\tMust possess a high school diploma or GED.<\/p>\n<p>Expectations:<\/p>\n<p>\u2022\tMust be self-motivated and able to work with minimal supervision.<\/p>\n<p>\u2022\tMust be able to communicate and coordinate with co-workers and supervisors.<\/p>\n<p>\u2022\tMust follow Company, State and Federal regulations, plans and policies.<\/p>\n<p>\u2022\tMust have high safety standards for self and others and wear required personal protective equipment.<\/p>\n<p>\u2022\u2022\tMust be able to read &amp; understand Material Safety Data Sheets and be able to operate power tools, hand tools, etc.<\/p>\n<p>\u2022\tMust be willing to work any assigned shift, overtime, weekends and holidays.<\/p>\n<p>Physical Requirements, Surface Operations:<\/p>\n<p>\u2022\tPerform constant functions including walking, standing, travel up and down stairs and vertical ladders, working overhead, bending f01ward and twisting<\/p>\n<p>\u2022\tMust have the ability to stand and squat without support for prolonged periods of time.<\/p>\n<p>,\t\u2022\tMust have the ability to be seated for up to 4 hours to operate equipment or vehicles.<\/p>\n<p>\u2022\tMust have the ability to work from elevated positions, walk\/climb up and down stairs\/steps and climb on and off equipment and ladders (ascend\/ descend 14' ve1iical ladder).<\/p>\n<p>\u2022\tMust have the ability to lift\/raise 10 - 50 lbs, without mechanical assistance frequently during the course of work shift.<\/p>\n<p>\u2022\tMust be able to cany box, 2-handed, 50ft with a load of 50lbs.<\/p>\n<p>\u2022\tMust be able to lift box, 2-handed, Floor to Shoulder with a load of 50lbs.<\/p>\n<p>\u2022\tMust be able to lift box, 2-handed, 17\" to 36\" with a load of 501bs.,<\/p>\n<p>\u2022\tMust be able to work overhead with a load of 5lbs in each hand,<\/p>\n<p>\u2022\tMust have adequate balance to safely work on 6\" wide beams.<\/p>\n<p>\u2022\tMust have the ability to perform repetitive hand and wrist motions (push, pull, twist, handle), and have rapid reflex movements of the arms and legs and good hand.to eye coordination.<\/p>\n<p>\u2022\tMust have the ability to work in extreme conditions, including but not limited to changing weather conditions, dust, mud, varying levels of noise from low to high, varying degrees of light and dark, in and around artificial light, hot work environments and in a MSHA recognized confined work area.<\/p>\n<p>\u2022\tMust be able to work with\/in equipment with moderate to high levels of vibration.<\/p>\n<p>\u2022\tMust have the ability to wear required protective footwear, hearing and eye protection, and other personal protective equipment as required by Company and MSHA.<\/p>","post_title":"Welder\/Mechanic","post_link":"https:\/\/turnerstaffing.com\/position\/welder-mechanic\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Mid Level","%location_country%":"United States","%location_city%":"Carlisle","%location_state_id%":"IN","%location_state_name%":"Indiana","%location_city_state%":"Carlisle, IN","%education%":"Unspecified","%department%":"","%description%":"<p>Job Summary\/Essential Functions: <\/p>\n<p>\u2022\t. Inspect, trouble shoot, and perform the required welding on all equipment at the jobsite,<\/p>\n<p>\u2022\t. Perform preventive maintenance and catastrophic failure repair.<\/p>\n<p>\u2022\tFuel and grease equipment when required.<\/p>\n<p>\u2022\tKeep records of work performed.<\/p>\n<p>Special skills or Qualifications Required:<\/p>\n<p>. \u2022\t\tMust have at least one year of experience in welding and repair of heavy diesel equipment and experience in hard surfacing and repair of ground engaging tools.<\/p>\n<p>\u2022\tMust have the ability to do the following:<\/p>\n<p>-\tWeld in all positions (horizontal, vertical and overhead).<\/p>\n<p>-\tProperly use a torch, air arc, stick weld, and wire weld.<\/p>\n<p>-\tHave a working knowledge of MIG and TIG units and the different types of metals associated with mining equipment.<\/p>\n<p>\u2022\tMust have at least one year of experience align boring and re-facing.<\/p>\n<p>\u2022\t\u2022\t. Must have basic math skills.<\/p>\n<p>\u2022\tMust possess a valid driver's license.<\/p>\n<p>\u2022\tMust possess a high school diploma or GED.<\/p>\n<p>Expectations:<\/p>\n<p>\u2022\tMust be self-motivated and able to work with minimal supervision.<\/p>\n<p>\u2022\tMust be able to communicate and coordinate with co-workers and supervisors.<\/p>\n<p>\u2022\tMust follow Company, State and Federal regulations, plans and policies.<\/p>\n<p>\u2022\tMust have high safety standards for self and others and wear required personal protective equipment.<\/p>\n<p>\u2022\u2022\tMust be able to read &amp; understand Material Safety Data Sheets and be able to operate power tools, hand tools, etc.<\/p>\n<p>\u2022\tMust be willing to work any assigned shift, overtime, weekends and holidays.<\/p>\n<p>Physical Requirements, Surface Operations:<\/p>\n<p>\u2022\tPerform constant functions including walking, standing, travel up and down stairs and vertical ladders, working overhead, bending f01ward and twisting<\/p>\n<p>\u2022\tMust have the ability to stand and squat without support for prolonged periods of time.<\/p>\n<p>,\t\u2022\tMust have the ability to be seated for up to 4 hours to operate equipment or vehicles.<\/p>\n<p>\u2022\tMust have the ability to work from elevated positions, walk\/climb up and down stairs\/steps and climb on and off equipment and ladders (ascend\/ descend 14' ve1iical ladder).<\/p>\n<p>\u2022\tMust have the ability to lift\/raise 10 - 50 lbs, without mechanical assistance frequently during the course of work shift.<\/p>\n<p>\u2022\tMust be able to cany box, 2-handed, 50ft with a load of 50lbs.<\/p>\n<p>\u2022\tMust be able to lift box, 2-handed, Floor to Shoulder with a load of 50lbs.<\/p>\n<p>\u2022\tMust be able to lift box, 2-handed, 17\" to 36\" with a load of 501bs.,<\/p>\n<p>\u2022\tMust be able to work overhead with a load of 5lbs in each hand,<\/p>\n<p>\u2022\tMust have adequate balance to safely work on 6\" wide beams.<\/p>\n<p>\u2022\tMust have the ability to perform repetitive hand and wrist motions (push, pull, twist, handle), and have rapid reflex movements of the arms and legs and good hand.to eye coordination.<\/p>\n<p>\u2022\tMust have the ability to work in extreme conditions, including but not limited to changing weather conditions, dust, mud, varying levels of noise from low to high, varying degrees of light and dark, in and around artificial light, hot work environments and in a MSHA recognized confined work area.<\/p>\n<p>\u2022\tMust be able to work with\/in equipment with moderate to high levels of vibration.<\/p>\n<p>\u2022\tMust have the ability to wear required protective footwear, hearing and eye protection, and other personal protective equipment as required by Company and MSHA.<\/p>","%category%":"Operations","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/a316504973a9-welder-mechanic","%breezy_id%":"a316504973a9","%breezy_friendly_id%":"a316504973a9-welder-mechanic","%breezy_created_date%":"2025-05-30T14:03:01.172Z","%breezy_updated_date%":"2025-11-14T20:44:26.097Z","%_wpgmp_location_city%":"Carlisle","%_wpgmp_location_state%":"IN","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Carlisle, IN, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"38.9623034","%_wpgmp_metabox_longitude%":"-87.4025572","%rank_math_internal_links_processed%":"1"}},"id":2480,"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 Staffing 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-6\/\" name=\"Haul Truck Driver\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Turner Staffing Group \u2013 Haul Truck Driver Do you love mining? Do you think differently? Are you ready to define&hellip;","address":"Linton, IN, USA","location":{"lat":"39.0347666","city":"Linton","state":"IN","country":"United States","lng":"-87.1658458","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/haul-truck-driver-6\/","zoom":19,"extra_fields":{"post_excerpt":"Turner Staffing 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 Staffing 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 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 mining Haul Truck Drivers for our fast-growing, forward thinking mining services company for a long term opportunity in Linton, IN.<\/p>\n<p>Turner Staffing 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 Staffing 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><br><\/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>","post_title":"Haul Truck Driver","post_link":"https:\/\/turnerstaffing.com\/position\/haul-truck-driver-6\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Associate","%location_country%":"United States","%location_city%":"Linton","%location_state_id%":"IN","%location_state_name%":"Indiana","%location_city_state%":"Linton, IN","%education%":"Unspecified","%department%":"","%description%":"<p><strong><u>Turner Staffing 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 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 mining Haul Truck Drivers for our fast-growing, forward thinking mining services company for a long term opportunity in Linton, IN.<\/p>\n<p>Turner Staffing 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 Staffing 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><br><\/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>","%category%":"Operations","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/17eabb7c25e4-haul-truck-driver","%breezy_id%":"17eabb7c25e4","%breezy_friendly_id%":"17eabb7c25e4-haul-truck-driver","%breezy_created_date%":"2025-05-29T13:50:01.472Z","%breezy_updated_date%":"2026-01-20T15:19:44.768Z","%_wpgmp_location_city%":"Linton","%_wpgmp_location_state%":"IN","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Linton, IN, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"39.0347666","%_wpgmp_metabox_longitude%":"-87.1658458","%rank_math_internal_links_processed%":"1"}},"id":2476,"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 Staffing 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\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Turner Staffing Group \u2013 Haul Truck Driver Do you love mining? Do you think differently? Are you ready to define&hellip;","address":"Carlisle, IN, USA","location":{"lat":"38.9623034","city":"Carlisle","state":"IN","country":"United States","lng":"-87.4025572","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/haul-truck-driver-2\/","zoom":19,"extra_fields":{"post_excerpt":"Turner Staffing 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 Staffing 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 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 mining Haul Truck Drivers for our fast-growing, forward thinking mining services company for a long term opportunity in Carlisle, IN.<\/p>\n<p>Turner Staffing 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 Staffing 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><br><\/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>","post_title":"Haul Truck Driver","post_link":"https:\/\/turnerstaffing.com\/position\/haul-truck-driver-2\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Associate","%location_country%":"United States","%location_city%":"Carlisle","%location_state_id%":"IN","%location_state_name%":"Indiana","%location_city_state%":"Carlisle, IN","%education%":"Unspecified","%department%":"","%description%":"<p><strong><u>Turner Staffing 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 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 mining Haul Truck Drivers for our fast-growing, forward thinking mining services company for a long term opportunity in Carlisle, IN.<\/p>\n<p>Turner Staffing 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 Staffing 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><br><\/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>","%category%":"Operations","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/f965badf42cf-haul-truck-driver","%breezy_id%":"f965badf42cf","%breezy_friendly_id%":"f965badf42cf-haul-truck-driver","%breezy_created_date%":"2025-05-23T17:11:35.282Z","%breezy_updated_date%":"2025-11-14T20:41:26.051Z","%_wpgmp_location_city%":"Carlisle","%_wpgmp_location_state%":"IN","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Carlisle, IN, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"38.9623034","%_wpgmp_metabox_longitude%":"-87.4025572","%rank_math_internal_links_processed%":"1"}},"id":2464,"infowindow_disable":false},{"source":"post","title":"D9 Dozer Operator","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    D9 Dozer Operator\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Job Summary: We are seeking a highly skilled and experienced Dozer Operator&nbsp;to operate a CAT D9 at a mining site&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/d9-dozer-operator\/\" name=\"D9 Dozer Operator\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Job Summary: We are seeking a highly skilled and experienced Dozer Operator&nbsp;to operate a CAT D9 at a mining site&hellip;","address":"Bullhead City, AZ, USA","location":{"lat":"35.1359386","city":"Bullhead City","state":"AZ","country":"United States","lng":"-114.5285981","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/d9-dozer-operator\/","zoom":19,"extra_fields":{"post_excerpt":"Job Summary: We are seeking a highly skilled and experienced Dozer Operator&nbsp;to operate a CAT D9 at a mining site&hellip;","post_content":"<h3><strong>Job Summary:<\/strong><\/h3>\n<p>We are seeking a highly skilled and experienced <strong>Dozer Operator<\/strong>&nbsp;to operate a <strong>CAT D9<\/strong> at a mining site near Bullhead City, AZ. The ideal candidate will have at least <strong>8 years of heavy equipment operation experience<\/strong>, with specific expertise in dozers in mining or similar high-production environments. This is a critical role in supporting daily site operations and ensuring material is moved safely and efficiently.<\/p>\n<h3><strong>Key Responsibilities:<\/strong><\/h3>\n<ul>\n<li>\n<p>Operate a D9 dozer in a safe, efficient, and productive manner<\/p>\n<\/li>\n<li>\n<p>Perform daily equipment inspections and basic preventive maintenance<\/p><\/li>\n<li>\n<p>Accurately follow production and safety protocols<\/p>\n<\/li>\n<li>\n<p>Communicate effectively with dispatch, supervisors, and other equipment operators<\/p>\n<\/li>\n<li>\n<p>Recognize and report mechanical issues promptly<\/p>\n<\/li>\n<li>\n<p>Maintain clean work areas and contribute to overall site housekeeping<\/p>\n<\/li>\n<li>\n<p>Work in various weather and environmental conditions<\/p>\n<\/li>\n<\/ul>\n<h3><strong>Qualifications:<\/strong><\/h3>\n<ul>\n<li>\n<p>Minimum <strong>8 years of experience<\/strong> operating dozers (preferably D9 or similar) in a mining or heavy construction environment<\/p>\n<\/li>\n<li>\n<p>Strong understanding of mining safety practices and MSHA regulations<\/p>\n<\/li>\n<li>\n<p>Ability to perform equipment walkarounds and document findings<\/p>\n<\/li>\n<li>\n<p>High school diploma or GED required<\/p>\n<\/li>\n<li>\n<p>Valid driver\u2019s license<\/p>\n<\/li>\n<li>\n<p>Must be able to pass a pre-employment drug test and background check<\/p>\n<\/li>\n<\/ul>\n<h3><strong>Preferred Attributes:<\/strong><\/h3>\n<ul>\n<li>\n<p>MSHA certification (current or previous)<\/p>\n<\/li>\n<li>\n<p>Strong mechanical aptitude<\/p>\n<\/li>\n<li>\n<p>Ability to work independently and as part of a team<\/p>\n<\/li>\n<li>\n<p>Excellent time management and organizational skills<\/p><\/li><\/ul>","post_title":"D9 Dozer Operator","post_link":"https:\/\/turnerstaffing.com\/position\/d9-dozer-operator\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Mid Level","%location_country%":"United States","%location_city%":"Bullhead City","%location_state_id%":"AZ","%location_state_name%":"Arizona","%location_city_state%":"Bullhead City, AZ","%education%":"Unspecified","%department%":"","%description%":"<h3><strong>Job Summary:<\/strong><\/h3>\n<p>We are seeking a highly skilled and experienced <strong>Dozer Operator<\/strong>&nbsp;to operate a <strong>CAT D9<\/strong> at a mining site near Bullhead City, AZ. The ideal candidate will have at least <strong>8 years of heavy equipment operation experience<\/strong>, with specific expertise in dozers in mining or similar high-production environments. This is a critical role in supporting daily site operations and ensuring material is moved safely and efficiently.<\/p>\n<h3><strong>Key Responsibilities:<\/strong><\/h3>\n<ul>\n<li>\n<p>Operate a D9 dozer in a safe, efficient, and productive manner<\/p>\n<\/li>\n<li>\n<p>Perform daily equipment inspections and basic preventive maintenance<\/p><\/li>\n<li>\n<p>Accurately follow production and safety protocols<\/p>\n<\/li>\n<li>\n<p>Communicate effectively with dispatch, supervisors, and other equipment operators<\/p>\n<\/li>\n<li>\n<p>Recognize and report mechanical issues promptly<\/p>\n<\/li>\n<li>\n<p>Maintain clean work areas and contribute to overall site housekeeping<\/p>\n<\/li>\n<li>\n<p>Work in various weather and environmental conditions<\/p>\n<\/li>\n<\/ul>\n<h3><strong>Qualifications:<\/strong><\/h3>\n<ul>\n<li>\n<p>Minimum <strong>8 years of experience<\/strong> operating dozers (preferably D9 or similar) in a mining or heavy construction environment<\/p>\n<\/li>\n<li>\n<p>Strong understanding of mining safety practices and MSHA regulations<\/p>\n<\/li>\n<li>\n<p>Ability to perform equipment walkarounds and document findings<\/p>\n<\/li>\n<li>\n<p>High school diploma or GED required<\/p>\n<\/li>\n<li>\n<p>Valid driver\u2019s license<\/p>\n<\/li>\n<li>\n<p>Must be able to pass a pre-employment drug test and background check<\/p>\n<\/li>\n<\/ul>\n<h3><strong>Preferred Attributes:<\/strong><\/h3>\n<ul>\n<li>\n<p>MSHA certification (current or previous)<\/p>\n<\/li>\n<li>\n<p>Strong mechanical aptitude<\/p>\n<\/li>\n<li>\n<p>Ability to work independently and as part of a team<\/p>\n<\/li>\n<li>\n<p>Excellent time management and organizational skills<\/p><\/li><\/ul>","%category%":"Operations","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/c208d6ed0cb9-d9-dozer-operator","%breezy_id%":"c208d6ed0cb9","%breezy_friendly_id%":"c208d6ed0cb9-d9-dozer-operator","%breezy_created_date%":"2025-05-21T18:51:32.421Z","%breezy_updated_date%":"2025-11-14T20:40:30.163Z","%_wpgmp_location_city%":"Bullhead City","%_wpgmp_location_state%":"AZ","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Bullhead City, AZ, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"35.1359386","%_wpgmp_metabox_longitude%":"-114.5285981","%rank_math_internal_links_processed%":"1"}},"id":2460,"infowindow_disable":false},{"source":"post","title":"DM45 Drill Operator","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    DM45 Drill Operator\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Job Summary: We are seeking a highly skilled and experienced Drill Operator&nbsp;to operate a DM45 at a mining site near&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/dm45-drill-operator\/\" name=\"DM45 Drill Operator\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Job Summary: We are seeking a highly skilled and experienced Drill Operator&nbsp;to operate a DM45 at a mining site near&hellip;","address":"Bullhead City, AZ, USA","location":{"lat":"35.1359386","city":"Bullhead City","state":"AZ","country":"United States","lng":"-114.5285981","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/dm45-drill-operator\/","zoom":19,"extra_fields":{"post_excerpt":"Job Summary: We are seeking a highly skilled and experienced Drill Operator&nbsp;to operate a DM45 at a mining site near&hellip;","post_content":"<h3><strong>Job Summary:<\/strong><\/h3>\n<p>We are seeking a highly skilled and experienced Drill Operator&nbsp;to operate a <strong>DM45<\/strong> at a mining site near Bullhead City, AZ. The ideal candidate will have at least <strong>8 years of heavy equipment operation experience<\/strong>, with specific expertise in drilling in mining or similar high-production environments. This is a critical role in supporting daily site operations and ensuring material is moved safely and efficiently.<\/p>\n<h3><strong>Key Responsibilities:<\/strong><\/h3>\n<ul>\n<li>\n<p>Operate a DM45 drill in a safe, efficient, and productive manner<\/p>\n<\/li>\n<li>\n<p>Perform daily equipment inspections and basic preventive maintenance<\/p><\/li>\n<li>\n<p>Accurately follow production and safety protocols<\/p>\n<\/li>\n<li>\n<p>Communicate effectively with dispatch, supervisors, and other equipment operators<\/p>\n<\/li>\n<li>\n<p>Recognize and report mechanical issues promptly<\/p>\n<\/li>\n<li>\n<p>Maintain clean work areas and contribute to overall site housekeeping<\/p>\n<\/li>\n<li>\n<p>Work in various weather and environmental conditions<\/p>\n<\/li>\n<\/ul>\n<h3><strong>Qualifications:<\/strong><\/h3>\n<ul>\n<li>\n<p>Minimum <strong>8 years of experience<\/strong> operating drills (preferably DM45 or similar) in a mining or heavy construction environment<\/p>\n<\/li>\n<li>\n<p>Strong understanding of mining safety practices and MSHA regulations<\/p>\n<\/li>\n<li>\n<p>Ability to perform equipment walkarounds and document findings<\/p>\n<\/li>\n<li>\n<p>High school diploma or GED required<\/p>\n<\/li>\n<li>\n<p>Valid driver\u2019s license<\/p>\n<\/li>\n<li>\n<p>Must be able to pass a pre-employment drug test and background check<\/p>\n<\/li>\n<\/ul>\n<h3><strong>Preferred Attributes:<\/strong><\/h3>\n<ul>\n<li>\n<p>MSHA certification (current or previous)<\/p>\n<\/li>\n<li>\n<p>Strong mechanical aptitude<\/p>\n<\/li>\n<li>\n<p>Ability to work independently and as part of a team<\/p>\n<\/li>\n<li>\n<p>Excellent time management and organizational skills<\/p><\/li><\/ul>","post_title":"DM45 Drill Operator","post_link":"https:\/\/turnerstaffing.com\/position\/dm45-drill-operator\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Mid Level","%location_country%":"United States","%location_city%":"Bullhead City","%location_state_id%":"AZ","%location_state_name%":"Arizona","%location_city_state%":"Bullhead City, AZ","%education%":"Unspecified","%department%":"","%description%":"<h3><strong>Job Summary:<\/strong><\/h3>\n<p>We are seeking a highly skilled and experienced Drill Operator&nbsp;to operate a <strong>DM45<\/strong> at a mining site near Bullhead City, AZ. The ideal candidate will have at least <strong>8 years of heavy equipment operation experience<\/strong>, with specific expertise in drilling in mining or similar high-production environments. This is a critical role in supporting daily site operations and ensuring material is moved safely and efficiently.<\/p>\n<h3><strong>Key Responsibilities:<\/strong><\/h3>\n<ul>\n<li>\n<p>Operate a DM45 drill in a safe, efficient, and productive manner<\/p>\n<\/li>\n<li>\n<p>Perform daily equipment inspections and basic preventive maintenance<\/p><\/li>\n<li>\n<p>Accurately follow production and safety protocols<\/p>\n<\/li>\n<li>\n<p>Communicate effectively with dispatch, supervisors, and other equipment operators<\/p>\n<\/li>\n<li>\n<p>Recognize and report mechanical issues promptly<\/p>\n<\/li>\n<li>\n<p>Maintain clean work areas and contribute to overall site housekeeping<\/p>\n<\/li>\n<li>\n<p>Work in various weather and environmental conditions<\/p>\n<\/li>\n<\/ul>\n<h3><strong>Qualifications:<\/strong><\/h3>\n<ul>\n<li>\n<p>Minimum <strong>8 years of experience<\/strong> operating drills (preferably DM45 or similar) in a mining or heavy construction environment<\/p>\n<\/li>\n<li>\n<p>Strong understanding of mining safety practices and MSHA regulations<\/p>\n<\/li>\n<li>\n<p>Ability to perform equipment walkarounds and document findings<\/p>\n<\/li>\n<li>\n<p>High school diploma or GED required<\/p>\n<\/li>\n<li>\n<p>Valid driver\u2019s license<\/p>\n<\/li>\n<li>\n<p>Must be able to pass a pre-employment drug test and background check<\/p>\n<\/li>\n<\/ul>\n<h3><strong>Preferred Attributes:<\/strong><\/h3>\n<ul>\n<li>\n<p>MSHA certification (current or previous)<\/p>\n<\/li>\n<li>\n<p>Strong mechanical aptitude<\/p>\n<\/li>\n<li>\n<p>Ability to work independently and as part of a team<\/p>\n<\/li>\n<li>\n<p>Excellent time management and organizational skills<\/p><\/li><\/ul>","%category%":"Operations","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/e89bae2b3cd3-dm45-drill-operator","%breezy_id%":"e89bae2b3cd3","%breezy_friendly_id%":"e89bae2b3cd3-dm45-drill-operator","%breezy_created_date%":"2025-05-21T18:53:10.289Z","%breezy_updated_date%":"2025-11-14T20:40:31.786Z","%_wpgmp_location_city%":"Bullhead City","%_wpgmp_location_state%":"AZ","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Bullhead City, AZ, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"35.1359386","%_wpgmp_metabox_longitude%":"-114.5285981","%rank_math_internal_links_processed%":"1"}},"id":2461,"infowindow_disable":false},{"source":"post","title":"993K Loader Operator","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    993K Loader Operator\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Job Summary: We are seeking a highly skilled and experienced Loader Operator to operate a Caterpillar 993K Loader at a&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/993k-loader-operator\/\" name=\"993K Loader Operator\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Job Summary: We are seeking a highly skilled and experienced Loader Operator to operate a Caterpillar 993K Loader at a&hellip;","address":"Bullhead City, AZ, USA","location":{"lat":"35.1359386","city":"Bullhead City","state":"AZ","country":"United States","lng":"-114.5285981","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/993k-loader-operator\/","zoom":19,"extra_fields":{"post_excerpt":"Job Summary: We are seeking a highly skilled and experienced Loader Operator to operate a Caterpillar 993K Loader at a&hellip;","post_content":"<h3><strong>Job Summary:<\/strong><\/h3>\n<p>We are seeking a highly skilled and experienced <strong>Loader Operator<\/strong> to operate a <strong>Caterpillar 993K Loader<\/strong> at a mining site near Bullhead City, AZ. The ideal candidate will have at least <strong>8 years of heavy equipment operation experience<\/strong>, with specific expertise in large loaders in mining or similar high-production environments. This is a critical role in supporting daily site operations and ensuring material is moved safely and efficiently.<\/p>\n<h3><strong>Key Responsibilities:<\/strong><\/h3>\n<ul>\n<li>\n<p>Operate a CAT 993K Loader in a safe, efficient, and productive manner<\/p>\n<\/li>\n<li>\n<p>Load haul trucks and maintain adequate feed to the crusher<\/p>\n<\/li>\n<li>\n<p>Perform daily equipment inspections and basic preventive maintenance<\/p>\n<\/li>\n<li>\n<p>Accurately follow production and safety protocols<\/p>\n<\/li>\n<li>\n<p>Communicate effectively with dispatch, supervisors, and other equipment operators<\/p>\n<\/li>\n<li>\n<p>Recognize and report mechanical issues promptly<\/p>\n<\/li>\n<li>\n<p>Maintain clean work areas and contribute to overall site housekeeping<\/p>\n<\/li>\n<li>\n<p>Work in various weather and environmental conditions<\/p>\n<\/li>\n<\/ul>\n<h3><strong>Qualifications:<\/strong><\/h3>\n<ul>\n<li>\n<p>Minimum <strong>8 years of experience<\/strong> operating large loaders (preferably CAT 993K or similar) in a mining or heavy construction environment<\/p>\n<\/li>\n<li>\n<p>Strong understanding of mining safety practices and MSHA regulations<\/p>\n<\/li>\n<li>\n<p>Ability to perform equipment walkarounds and document findings<\/p>\n<\/li>\n<li>\n<p>High school diploma or GED required<\/p>\n<\/li>\n<li>\n<p>Valid driver\u2019s license<\/p>\n<\/li>\n<li>\n<p>Must be able to pass a pre-employment drug test and background check<\/p>\n<\/li>\n<\/ul>\n<h3><strong>Preferred Attributes:<\/strong><\/h3>\n<ul>\n<li>\n<p>MSHA certification (current or previous)<\/p>\n<\/li>\n<li>\n<p>Strong mechanical aptitude<\/p>\n<\/li>\n<li>\n<p>Ability to work independently and as part of a team<\/p>\n<\/li>\n<li>\n<p>Excellent time management and organizational skills<\/p><\/li><\/ul>","post_title":"993K Loader Operator","post_link":"https:\/\/turnerstaffing.com\/position\/993k-loader-operator\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Mid Level","%location_country%":"United States","%location_city%":"Bullhead City","%location_state_id%":"AZ","%location_state_name%":"Arizona","%location_city_state%":"Bullhead City, AZ","%education%":"Unspecified","%department%":"","%description%":"<h3><strong>Job Summary:<\/strong><\/h3>\n<p>We are seeking a highly skilled and experienced <strong>Loader Operator<\/strong> to operate a <strong>Caterpillar 993K Loader<\/strong> at a mining site near Bullhead City, AZ. The ideal candidate will have at least <strong>8 years of heavy equipment operation experience<\/strong>, with specific expertise in large loaders in mining or similar high-production environments. This is a critical role in supporting daily site operations and ensuring material is moved safely and efficiently.<\/p>\n<h3><strong>Key Responsibilities:<\/strong><\/h3>\n<ul>\n<li>\n<p>Operate a CAT 993K Loader in a safe, efficient, and productive manner<\/p>\n<\/li>\n<li>\n<p>Load haul trucks and maintain adequate feed to the crusher<\/p>\n<\/li>\n<li>\n<p>Perform daily equipment inspections and basic preventive maintenance<\/p>\n<\/li>\n<li>\n<p>Accurately follow production and safety protocols<\/p>\n<\/li>\n<li>\n<p>Communicate effectively with dispatch, supervisors, and other equipment operators<\/p>\n<\/li>\n<li>\n<p>Recognize and report mechanical issues promptly<\/p>\n<\/li>\n<li>\n<p>Maintain clean work areas and contribute to overall site housekeeping<\/p>\n<\/li>\n<li>\n<p>Work in various weather and environmental conditions<\/p>\n<\/li>\n<\/ul>\n<h3><strong>Qualifications:<\/strong><\/h3>\n<ul>\n<li>\n<p>Minimum <strong>8 years of experience<\/strong> operating large loaders (preferably CAT 993K or similar) in a mining or heavy construction environment<\/p>\n<\/li>\n<li>\n<p>Strong understanding of mining safety practices and MSHA regulations<\/p>\n<\/li>\n<li>\n<p>Ability to perform equipment walkarounds and document findings<\/p>\n<\/li>\n<li>\n<p>High school diploma or GED required<\/p>\n<\/li>\n<li>\n<p>Valid driver\u2019s license<\/p>\n<\/li>\n<li>\n<p>Must be able to pass a pre-employment drug test and background check<\/p>\n<\/li>\n<\/ul>\n<h3><strong>Preferred Attributes:<\/strong><\/h3>\n<ul>\n<li>\n<p>MSHA certification (current or previous)<\/p>\n<\/li>\n<li>\n<p>Strong mechanical aptitude<\/p>\n<\/li>\n<li>\n<p>Ability to work independently and as part of a team<\/p>\n<\/li>\n<li>\n<p>Excellent time management and organizational skills<\/p><\/li><\/ul>","%category%":"Operations","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/739db71f4057-993k-loader-operator","%breezy_id%":"739db71f4057","%breezy_friendly_id%":"739db71f4057-993k-loader-operator","%breezy_created_date%":"2025-05-21T18:47:48.115Z","%breezy_updated_date%":"2026-01-14T19:04:00.757Z","%_wpgmp_location_city%":"Bullhead City","%_wpgmp_location_state%":"AZ","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Bullhead City, AZ, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"35.1359386","%_wpgmp_metabox_longitude%":"-114.5285981","%rank_math_internal_links_processed%":"1"}},"id":2458,"infowindow_disable":false},{"source":"post","title":"777 Haul Truck Driver","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    777 Haul Truck Driver\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Job Summary: We are seeking a highly skilled and experienced Haul Truck Driver&nbsp;to operate a 777 at a mining site&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/777-haul-truck-driver\/\" name=\"777 Haul Truck Driver\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Job Summary: We are seeking a highly skilled and experienced Haul Truck Driver&nbsp;to operate a 777 at a mining site&hellip;","address":"Bullhead City, AZ, USA","location":{"lat":"35.1359386","city":"Bullhead City","state":"AZ","country":"United States","lng":"-114.5285981","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/777-haul-truck-driver\/","zoom":19,"extra_fields":{"post_excerpt":"Job Summary: We are seeking a highly skilled and experienced Haul Truck Driver&nbsp;to operate a 777 at a mining site&hellip;","post_content":"<h3><strong>Job Summary:<\/strong><\/h3>\n<p>We are seeking a highly skilled and experienced <strong>Haul Truck Driver<\/strong>&nbsp;to operate a <strong>777<\/strong> at a mining site near Bullhead City, AZ. The ideal candidate will have at least <strong>8 years of heavy equipment operation experience<\/strong>, with specific expertise in haul trucks in mining or similar high-production environments. This is a critical role in supporting daily site operations and ensuring material is moved safely and efficiently.<\/p>\n<h3><strong>Key Responsibilities:<\/strong><\/h3>\n<ul>\n<li>\n<p>Operate a 777 haul truck in a safe, efficient, and productive manner<\/p>\n<\/li>\n<li>\n<p>Perform daily equipment inspections and basic preventive maintenance<\/p><\/li>\n<li>\n<p>Accurately follow production and safety protocols<\/p>\n<\/li>\n<li>\n<p>Communicate effectively with dispatch, supervisors, and other equipment operators<\/p>\n<\/li>\n<li>\n<p>Recognize and report mechanical issues promptly<\/p>\n<\/li>\n<li>\n<p>Maintain clean work areas and contribute to overall site housekeeping<\/p>\n<\/li>\n<li>\n<p>Work in various weather and environmental conditions<\/p>\n<\/li>\n<\/ul>\n<h3><strong>Qualifications:<\/strong><\/h3>\n<ul>\n<li>\n<p>Minimum <strong>8 years of experience<\/strong> operating haul trucks (preferably 777 or similar) in a mining or heavy construction environment<\/p>\n<\/li>\n<li>\n<p>Strong understanding of mining safety practices and MSHA regulations<\/p>\n<\/li>\n<li>\n<p>Ability to perform equipment walkarounds and document findings<\/p>\n<\/li>\n<li>\n<p>High school diploma or GED required<\/p>\n<\/li>\n<li>\n<p>Valid driver\u2019s license<\/p>\n<\/li>\n<li>\n<p>Must be able to pass a pre-employment drug test and background check<\/p>\n<\/li>\n<\/ul>\n<h3><strong>Preferred Attributes:<\/strong><\/h3>\n<ul>\n<li>\n<p>MSHA certification (current or previous)<\/p>\n<\/li>\n<li>\n<p>Strong mechanical aptitude<\/p>\n<\/li>\n<li>\n<p>Ability to work independently and as part of a team<\/p>\n<\/li>\n<li>\n<p>Excellent time management and organizational skills<\/p><\/li><\/ul>","post_title":"777 Haul Truck Driver","post_link":"https:\/\/turnerstaffing.com\/position\/777-haul-truck-driver\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Mid Level","%location_country%":"United States","%location_city%":"Bullhead City","%location_state_id%":"AZ","%location_state_name%":"Arizona","%location_city_state%":"Bullhead City, AZ","%education%":"Unspecified","%department%":"","%description%":"<h3><strong>Job Summary:<\/strong><\/h3>\n<p>We are seeking a highly skilled and experienced <strong>Haul Truck Driver<\/strong>&nbsp;to operate a <strong>777<\/strong> at a mining site near Bullhead City, AZ. The ideal candidate will have at least <strong>8 years of heavy equipment operation experience<\/strong>, with specific expertise in haul trucks in mining or similar high-production environments. This is a critical role in supporting daily site operations and ensuring material is moved safely and efficiently.<\/p>\n<h3><strong>Key Responsibilities:<\/strong><\/h3>\n<ul>\n<li>\n<p>Operate a 777 haul truck in a safe, efficient, and productive manner<\/p>\n<\/li>\n<li>\n<p>Perform daily equipment inspections and basic preventive maintenance<\/p><\/li>\n<li>\n<p>Accurately follow production and safety protocols<\/p>\n<\/li>\n<li>\n<p>Communicate effectively with dispatch, supervisors, and other equipment operators<\/p>\n<\/li>\n<li>\n<p>Recognize and report mechanical issues promptly<\/p>\n<\/li>\n<li>\n<p>Maintain clean work areas and contribute to overall site housekeeping<\/p>\n<\/li>\n<li>\n<p>Work in various weather and environmental conditions<\/p>\n<\/li>\n<\/ul>\n<h3><strong>Qualifications:<\/strong><\/h3>\n<ul>\n<li>\n<p>Minimum <strong>8 years of experience<\/strong> operating haul trucks (preferably 777 or similar) in a mining or heavy construction environment<\/p>\n<\/li>\n<li>\n<p>Strong understanding of mining safety practices and MSHA regulations<\/p>\n<\/li>\n<li>\n<p>Ability to perform equipment walkarounds and document findings<\/p>\n<\/li>\n<li>\n<p>High school diploma or GED required<\/p>\n<\/li>\n<li>\n<p>Valid driver\u2019s license<\/p>\n<\/li>\n<li>\n<p>Must be able to pass a pre-employment drug test and background check<\/p>\n<\/li>\n<\/ul>\n<h3><strong>Preferred Attributes:<\/strong><\/h3>\n<ul>\n<li>\n<p>MSHA certification (current or previous)<\/p>\n<\/li>\n<li>\n<p>Strong mechanical aptitude<\/p>\n<\/li>\n<li>\n<p>Ability to work independently and as part of a team<\/p>\n<\/li>\n<li>\n<p>Excellent time management and organizational skills<\/p><\/li><\/ul>","%category%":"Operations","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/ec0b5018a4b7-777-haul-truck-driver","%breezy_id%":"ec0b5018a4b7","%breezy_friendly_id%":"ec0b5018a4b7-777-haul-truck-driver","%breezy_created_date%":"2025-05-21T18:49:11.934Z","%breezy_updated_date%":"2026-01-14T19:03:57.213Z","%_wpgmp_location_city%":"Bullhead City","%_wpgmp_location_state%":"AZ","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Bullhead City, AZ, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"35.1359386","%_wpgmp_metabox_longitude%":"-114.5285981","%rank_math_internal_links_processed%":"1"}},"id":2459,"infowindow_disable":false},{"source":"post","title":"Grading Foreman","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Grading Foreman\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Position: Grading Foreman Location: Charleston, SC Employment Type: Full-Time, Long-Term What are we looking for? We are looking Grading Foreman&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/grading-foreman\/\" name=\"Grading Foreman\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Position: Grading Foreman Location: Charleston, SC Employment Type: Full-Time, Long-Term What are we looking for? We are looking Grading Foreman&hellip;","address":"Charleston, SC, USA","location":{"lat":"32.7833163","city":"Charleston","state":"SC","country":"United States","lng":"-79.9319664","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/grading-foreman\/","zoom":19,"extra_fields":{"post_excerpt":"Position: Grading Foreman Location: Charleston, SC Employment Type: Full-Time, Long-Term What are we looking for? We are looking Grading Foreman&hellip;","post_content":"<p>Position: Grading Foreman<\/p>\n<p>Location: Charleston, SC<\/p>\n<p>Employment Type: Full-Time, Long-Term<\/p>\n<p>What are we looking for? We are looking Grading Foreman to run a grading crew and&nbsp;ensures the project tasks set by the Project Superintendent are being properly&nbsp;completed, and the crew is properly staffed and equipped.<\/p>\n<p>What you will get to do:<\/p>\n<ul><li>Responsible for the interpretation of the construction drawings and specifications related to the Project.<\/li><li>Inspect work progress, equipment, or construction sites to verify safety or to ensure that specifications are met.<\/li><li>Train workers in construction methods, operation of equipment, safety procedures, or company policies.<\/li><li>Locate, measure, and mark site locations or placement of structures or equipment, using measuring and marking equipment.<\/li><li>Confer with managerial or technical personnel, other departments, or contractors to resolve problems or to coordinate activities.<\/li><li>Direct crew members as to the proper procedures to build the job safely, on time and under budget.<\/li><li>Work directly with the Project Superintendent to ensure client needs are being met.<\/li><li>Record information, such as personnel, production, or operational data on specified forms or reports.<\/li><li>Suggest or initiate personnel actions, such as promotions, transfers, or hires.<\/li><\/ul>\n<p>Who you are:<\/p>\n<ul><li>You are a leader<\/li><li>You have an extreme attention to detail<\/li><li>You have the ability to stay focused in a fast-paced environment<\/li><li>You are a self-starter and highly motivated<\/li><li>Even better if you have experience managing paving crews<\/li><li>Even better if you have experience operating asphalt paving equipment<\/li><\/ul>\n<p>Why Join Us?<\/p>\n<ul><li>Opportunities for career growth and advancement within the company.<\/li><li>Be part of a company with a strong reputation and deep community roots.<\/li><li>Work with state-of-the-art equipment and a highly skilled team.<\/li><li>Be part of a people-first company that prioritizes safety and rewards high performers<\/li><\/ul>","post_title":"Grading Foreman","post_link":"https:\/\/turnerstaffing.com\/position\/grading-foreman\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Mid Level","%location_country%":"United States","%location_city%":"Charleston","%location_state_id%":"SC","%location_state_name%":"South Carolina","%location_city_state%":"Charleston, SC","%education%":"","%department%":"","%description%":"<p>Position: Grading Foreman<\/p>\n<p>Location: Charleston, SC<\/p>\n<p>Employment Type: Full-Time, Long-Term<\/p>\n<p>What are we looking for? We are looking Grading Foreman to run a grading crew and&nbsp;ensures the project tasks set by the Project Superintendent are being properly&nbsp;completed, and the crew is properly staffed and equipped.<\/p>\n<p>What you will get to do:<\/p>\n<ul><li>Responsible for the interpretation of the construction drawings and specifications related to the Project.<\/li><li>Inspect work progress, equipment, or construction sites to verify safety or to ensure that specifications are met.<\/li><li>Train workers in construction methods, operation of equipment, safety procedures, or company policies.<\/li><li>Locate, measure, and mark site locations or placement of structures or equipment, using measuring and marking equipment.<\/li><li>Confer with managerial or technical personnel, other departments, or contractors to resolve problems or to coordinate activities.<\/li><li>Direct crew members as to the proper procedures to build the job safely, on time and under budget.<\/li><li>Work directly with the Project Superintendent to ensure client needs are being met.<\/li><li>Record information, such as personnel, production, or operational data on specified forms or reports.<\/li><li>Suggest or initiate personnel actions, such as promotions, transfers, or hires.<\/li><\/ul>\n<p>Who you are:<\/p>\n<ul><li>You are a leader<\/li><li>You have an extreme attention to detail<\/li><li>You have the ability to stay focused in a fast-paced environment<\/li><li>You are a self-starter and highly motivated<\/li><li>Even better if you have experience managing paving crews<\/li><li>Even better if you have experience operating asphalt paving equipment<\/li><\/ul>\n<p>Why Join Us?<\/p>\n<ul><li>Opportunities for career growth and advancement within the company.<\/li><li>Be part of a company with a strong reputation and deep community roots.<\/li><li>Work with state-of-the-art equipment and a highly skilled team.<\/li><li>Be part of a people-first company that prioritizes safety and rewards high performers<\/li><\/ul>","%category%":"Management","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/b38e2957cc67-grading-foreman","%breezy_id%":"b38e2957cc67","%breezy_friendly_id%":"b38e2957cc67-grading-foreman","%breezy_created_date%":"2025-05-16T14:52:51.282Z","%breezy_updated_date%":"2025-11-14T20:41:23.499Z","%_wpgmp_location_city%":"Charleston","%_wpgmp_location_state%":"SC","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Charleston, SC, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"32.7833163","%_wpgmp_metabox_longitude%":"-79.9319664","%rank_math_internal_links_processed%":"1"}},"id":2448,"infowindow_disable":false},{"source":"post","title":"Paving Foreman","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Paving Foreman\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Position: Paving Foreman Location: Charleston, SC Employment Type: Full-Time, Long-Term What are we looking for? We are looking for a&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/paving-foreman\/\" name=\"Paving Foreman\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Position: Paving Foreman Location: Charleston, SC Employment Type: Full-Time, Long-Term What are we looking for? We are looking for a&hellip;","address":"Charleston, SC, USA","location":{"lat":"32.7833163","city":"Charleston","state":"SC","country":"United States","lng":"-79.9319664","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/paving-foreman\/","zoom":19,"extra_fields":{"post_excerpt":"Position: Paving Foreman Location: Charleston, SC Employment Type: Full-Time, Long-Term What are we looking for? We are looking for a&hellip;","post_content":"<p>Position: Paving Foreman<\/p>\n<p>Location: Charleston, SC<\/p>\n<p>Employment Type: Full-Time, Long-Term<\/p>\n<p>What are we looking for? We are looking for a Paving Foreman to run grading crews and ensures the project is properly planned, staffed, and equipped.<\/p>\n<p>What you will get to do:<\/p>\n<p>\u2022\tResponsible for the interpretation of the construction drawings and specifications related to the Project.<\/p>\n<p>\u2022\tUtilize knowledge of mix types, codes and their applications, along with a familiarity of the Supplemental Technical Specifications SC - M - 400 - HMA <\/p>\n<p>Quality Assurance<\/p>\n<p>\u2022\tRecognize the differences between mainline and low tonnage asphalt application, using knowledge of temperature restrictions, required thickness rates, etc. to ensure accuracy on the project.<\/p>\n<p>\u2022\tInspect work progress, equipment, or construction sites to verify safety or to ensure that specifications are met.<\/p>\n<p>\u2022\tTrain workers in construction methods, operation of equipment, safety procedures, or company policies.<\/p>\n<p>\u2022\tLocate, measure, and mark site locations or placement of structures or equipment, using measuring and marking equipment.<\/p>\n<p>\u2022\tConfer with managerial or technical personnel, other departments, or contractors to resolve problems or to coordinate activities.<\/p>\n<p>\u2022\tDirect crew members as to the proper procedures to build the job safely, on time and under budget.<\/p>\n<p>\u2022\tWork directly with the Project Superintendent to ensure client needs are being met.<\/p>\n<p>\u2022\tRecord information, such as personnel, production, or operational data on specified forms or reports.<\/p>\n<p>\u2022\tSuggest or initiate personnel actions, such as promotions, transfers, or hires.<\/p>\n<p>Who you are:<\/p>\n<p>\u2022\tYou are a leader<\/p>\n<p>\u2022\tYou have extreme attention to detail<\/p>\n<p>\u2022\tYou have the ability to stay focused in a fast-paced environment<\/p>\n<p>\u2022\tYou are a self-starter and highly motivated<\/p>\n<p>\u2022\tEven better if you have experience managing paving crews<\/p>\n<p>\u2022\tEven better if you have experience operating asphalt paving equipment<\/p>\n<p>Why Join Us?<\/p>\n<p>\u2022\tOpportunities for career growth and advancement within the company.<\/p>\n<p>\u2022\tBe part of a company with a strong reputation and deep community roots.<\/p>\n<p>\u2022\tWork with state-of-the-art equipment and a highly skilled team.<\/p>\n<p>\u2022\tBe part of a people-first company that prioritizes safety and rewards high performers<\/p>","post_title":"Paving Foreman","post_link":"https:\/\/turnerstaffing.com\/position\/paving-foreman\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Mid Level","%location_country%":"United States","%location_city%":"Charleston","%location_state_id%":"SC","%location_state_name%":"South Carolina","%location_city_state%":"Charleston, SC","%education%":"","%department%":"","%description%":"<p>Position: Paving Foreman<\/p>\n<p>Location: Charleston, SC<\/p>\n<p>Employment Type: Full-Time, Long-Term<\/p>\n<p>What are we looking for? We are looking for a Paving Foreman to run grading crews and ensures the project is properly planned, staffed, and equipped.<\/p>\n<p>What you will get to do:<\/p>\n<p>\u2022\tResponsible for the interpretation of the construction drawings and specifications related to the Project.<\/p>\n<p>\u2022\tUtilize knowledge of mix types, codes and their applications, along with a familiarity of the Supplemental Technical Specifications SC - M - 400 - HMA <\/p>\n<p>Quality Assurance<\/p>\n<p>\u2022\tRecognize the differences between mainline and low tonnage asphalt application, using knowledge of temperature restrictions, required thickness rates, etc. to ensure accuracy on the project.<\/p>\n<p>\u2022\tInspect work progress, equipment, or construction sites to verify safety or to ensure that specifications are met.<\/p>\n<p>\u2022\tTrain workers in construction methods, operation of equipment, safety procedures, or company policies.<\/p>\n<p>\u2022\tLocate, measure, and mark site locations or placement of structures or equipment, using measuring and marking equipment.<\/p>\n<p>\u2022\tConfer with managerial or technical personnel, other departments, or contractors to resolve problems or to coordinate activities.<\/p>\n<p>\u2022\tDirect crew members as to the proper procedures to build the job safely, on time and under budget.<\/p>\n<p>\u2022\tWork directly with the Project Superintendent to ensure client needs are being met.<\/p>\n<p>\u2022\tRecord information, such as personnel, production, or operational data on specified forms or reports.<\/p>\n<p>\u2022\tSuggest or initiate personnel actions, such as promotions, transfers, or hires.<\/p>\n<p>Who you are:<\/p>\n<p>\u2022\tYou are a leader<\/p>\n<p>\u2022\tYou have extreme attention to detail<\/p>\n<p>\u2022\tYou have the ability to stay focused in a fast-paced environment<\/p>\n<p>\u2022\tYou are a self-starter and highly motivated<\/p>\n<p>\u2022\tEven better if you have experience managing paving crews<\/p>\n<p>\u2022\tEven better if you have experience operating asphalt paving equipment<\/p>\n<p>Why Join Us?<\/p>\n<p>\u2022\tOpportunities for career growth and advancement within the company.<\/p>\n<p>\u2022\tBe part of a company with a strong reputation and deep community roots.<\/p>\n<p>\u2022\tWork with state-of-the-art equipment and a highly skilled team.<\/p>\n<p>\u2022\tBe part of a people-first company that prioritizes safety and rewards high performers<\/p>","%category%":"Management","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/1ebec34135d3-paving-foreman","%breezy_id%":"1ebec34135d3","%breezy_friendly_id%":"1ebec34135d3-paving-foreman","%breezy_created_date%":"2025-05-16T15:07:25.293Z","%breezy_updated_date%":"2026-01-14T17:29:07.201Z","%_wpgmp_location_city%":"Charleston","%_wpgmp_location_state%":"SC","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Charleston, SC, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"32.7833163","%_wpgmp_metabox_longitude%":"-79.9319664","%rank_math_internal_links_processed%":"1"}},"id":2449,"infowindow_disable":false},{"source":"post","title":"Paving Project Manager","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Paving Project Manager\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Position: Paving Project Manager Location: Charleston,&nbsp;SC Employment Type: Full-Time, Long-Term Role Overview We\u2019re seeking a seasoned Paving Project Manager with&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/paving-project-manager\/\" name=\"Paving Project Manager\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Position: Paving Project Manager Location: Charleston,&nbsp;SC Employment Type: Full-Time, Long-Term Role Overview We\u2019re seeking a seasoned Paving Project Manager with&hellip;","address":"Charleston, SC, USA","location":{"lat":"32.7833163","city":"Charleston","state":"SC","country":"United States","lng":"-79.9319664","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/paving-project-manager\/","zoom":19,"extra_fields":{"post_excerpt":"Position: Paving Project Manager Location: Charleston,&nbsp;SC Employment Type: Full-Time, Long-Term Role Overview We\u2019re seeking a seasoned Paving Project Manager with&hellip;","post_content":"<p>Position: Paving Project Manager<\/p>\n<p>Location: Charleston,&nbsp;SC<\/p>\n<p>Employment Type: Full-Time, Long-Term<\/p>\n<p><\/p>\n<h3>Role Overview<\/h3>\n<p>We\u2019re seeking a seasoned <strong>Paving Project Manager<\/strong> with <strong>5+ years<\/strong> of hands-on experience managing heavy highway asphalt projects. In this role, you will:<\/p>\n<ul>\n<li>\n<p><strong>Initially<\/strong> oversee <strong>two (2) large paving projects<\/strong>, ensuring they meet scope, schedule, budget, and quality targets.<\/p>\n<\/li>\n<li>\n<p><strong>Subsequently<\/strong> manage <strong>three to four (3\u20134) concurrent projects<\/strong> as our pipeline grows.<\/p>\n<\/li>\n<li>\n<p>Drive operational excellence, mentor your project teams, and collaborate with estimating, safety, and maintenance departments.<\/p>\n<\/li>\n<\/ul>\n<h3>Key Responsibilities<\/h3><p><\/p><p>General role and responsibilities would include:<\/p>\n\n\n<p><\/p><ul><li>Primary point of contact for assigned projects<\/li><li>Responsible for all correspondence to clients<\/li><li>Build and manage project schedules<\/li><li>Monitor and maintain project submittal process<\/li><li>Track quantities and field changes<\/li><li>Process all change orders<\/li><li>Review and track job cost<\/li><li>Prepare monthly invoices to project owner<\/li><li>Scheduling of all subcontractors<\/li><li>Attend and facilitate all project meetings (i.e. progress meetings with owner, pre and post construction meetings, etc.)<\/li><li>Work directly with Project Superintendents and Operations<\/li><li>Ensure safe, timely and under budget completion of all assigned projects<\/li>\n<li>\n<p>Coordinate subcontractors, material deliveries, and equipment to maintain workflow.<\/p><\/li>\n\n\n<li>\n<p><strong>Quality &amp; Safety Oversight<\/strong><\/p>\n<ul>\n<li>\n<p>Enforce industry best practices and company safety policies on site.<\/p>\n<\/li>\n<li>\n<p>Conduct regular site inspections and pre-pave reviews to ensure asphalt compaction and drainage specifications are met.<\/p>\n<\/li>\n<\/ul>\n<\/li>\n<li>\n<p><strong>Client &amp; Stakeholder Management<\/strong><\/p>\n<ul>\n<li>\n<p>Serve as the primary point of contact for owners, engineers, and municipal agencies.<\/p>\n<\/li>\n<li>\n<p>Prepare and present progress reports, change orders, and final project documentation.<\/p>\n<\/li>\n<\/ul>\n<\/li>\n<li>\n<p><strong>Team Leadership<\/strong><\/p>\n<ul>\n<li>\n<p>Supervise field crews, foremen, and junior staff.<\/p>\n<\/li>\n<li>\n<p>Foster a collaborative environment that encourages problem-solving and continuous improvement.<\/p>\n<\/li>\n<\/ul>\n<\/li>\n<li>\n<p><strong>Cost Control &amp; Profitability<\/strong><\/p>\n<ul>\n<li>\n<p>Monitor job costs and implement corrective actions to protect margins.<\/p>\n<\/li>\n<li>\n<p>Participate in monthly project review meetings to evaluate performance against profit-sharing targets.<\/p>\n<\/li>\n<\/ul>\n<\/li>\n<\/ul>\n<h3>Required Qualifications<\/h3>\n<ul>\n<li>\n<p><strong>Experience:<\/strong> Minimum <strong>5 years<\/strong> managing heavy highway asphalt projects (paving, milling, overlays).<\/p>\n<\/li>\n<li>\n<p><strong>Technical Knowledge:<\/strong><\/p>\n<ul>\n<li>\n<p>Proficient in asphalt mix design, compaction techniques, and equipment operation (pavers, rollers, milling machines).<\/p>\n<\/li>\n<li>\n<p>Familiarity with state DOT specifications and ASTM testing procedures.<\/p>\n<\/li>\n<\/ul>\n<\/li>\n<li>\n<p><strong>Project Management Skills:<\/strong><\/p>\n<ul>\n<li>\n<p>Strong scheduling, budgeting, and resource-allocation capabilities.<\/p>\n<\/li>\n<li>\n<p>Comfortable using construction management software (e.g., Procore, HCSS HeavyBid).<\/p>\n<\/li>\n<\/ul>\n<\/li>\n<li>\n<p><strong>Leadership &amp; Communication:<\/strong><\/p>\n<ul>\n<li>\n<p>Excellent interpersonal skills; able to lead crews and negotiate with vendors.<\/p>\n<\/li>\n<li>\n<p>Clear, concise report writing and presentation abilities.<\/p>\n<\/li>\n<\/ul>\n<\/li>\n<li>\n<p><strong>Certifications (preferred):<\/strong><\/p>\n<ul>\n<li>\n<p>OSHA 30-Hour Construction Safety<\/p>\n<\/li>\n<li>\n<p>AASHTO Quality Technician (Level I or II)<\/p>\n<\/li>\n<li>\n<p>PMP or CCM credential<\/p><\/li><\/ul><\/li><\/ul>","post_title":"Paving Project Manager","post_link":"https:\/\/turnerstaffing.com\/position\/paving-project-manager\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Senior","%location_country%":"United States","%location_city%":"Charleston","%location_state_id%":"SC","%location_state_name%":"South Carolina","%location_city_state%":"Charleston, SC","%education%":"","%department%":"","%description%":"<p>Position: Paving Project Manager<\/p>\n<p>Location: Charleston,&nbsp;SC<\/p>\n<p>Employment Type: Full-Time, Long-Term<\/p>\n<p><\/p>\n<h3>Role Overview<\/h3>\n<p>We\u2019re seeking a seasoned <strong>Paving Project Manager<\/strong> with <strong>5+ years<\/strong> of hands-on experience managing heavy highway asphalt projects. In this role, you will:<\/p>\n<ul>\n<li>\n<p><strong>Initially<\/strong> oversee <strong>two (2) large paving projects<\/strong>, ensuring they meet scope, schedule, budget, and quality targets.<\/p>\n<\/li>\n<li>\n<p><strong>Subsequently<\/strong> manage <strong>three to four (3\u20134) concurrent projects<\/strong> as our pipeline grows.<\/p>\n<\/li>\n<li>\n<p>Drive operational excellence, mentor your project teams, and collaborate with estimating, safety, and maintenance departments.<\/p>\n<\/li>\n<\/ul>\n<h3>Key Responsibilities<\/h3><p><\/p><p>General role and responsibilities would include:<\/p>\n\n\n<p><\/p><ul><li>Primary point of contact for assigned projects<\/li><li>Responsible for all correspondence to clients<\/li><li>Build and manage project schedules<\/li><li>Monitor and maintain project submittal process<\/li><li>Track quantities and field changes<\/li><li>Process all change orders<\/li><li>Review and track job cost<\/li><li>Prepare monthly invoices to project owner<\/li><li>Scheduling of all subcontractors<\/li><li>Attend and facilitate all project meetings (i.e. progress meetings with owner, pre and post construction meetings, etc.)<\/li><li>Work directly with Project Superintendents and Operations<\/li><li>Ensure safe, timely and under budget completion of all assigned projects<\/li>\n<li>\n<p>Coordinate subcontractors, material deliveries, and equipment to maintain workflow.<\/p><\/li>\n\n\n<li>\n<p><strong>Quality &amp; Safety Oversight<\/strong><\/p>\n<ul>\n<li>\n<p>Enforce industry best practices and company safety policies on site.<\/p>\n<\/li>\n<li>\n<p>Conduct regular site inspections and pre-pave reviews to ensure asphalt compaction and drainage specifications are met.<\/p>\n<\/li>\n<\/ul>\n<\/li>\n<li>\n<p><strong>Client &amp; Stakeholder Management<\/strong><\/p>\n<ul>\n<li>\n<p>Serve as the primary point of contact for owners, engineers, and municipal agencies.<\/p>\n<\/li>\n<li>\n<p>Prepare and present progress reports, change orders, and final project documentation.<\/p>\n<\/li>\n<\/ul>\n<\/li>\n<li>\n<p><strong>Team Leadership<\/strong><\/p>\n<ul>\n<li>\n<p>Supervise field crews, foremen, and junior staff.<\/p>\n<\/li>\n<li>\n<p>Foster a collaborative environment that encourages problem-solving and continuous improvement.<\/p>\n<\/li>\n<\/ul>\n<\/li>\n<li>\n<p><strong>Cost Control &amp; Profitability<\/strong><\/p>\n<ul>\n<li>\n<p>Monitor job costs and implement corrective actions to protect margins.<\/p>\n<\/li>\n<li>\n<p>Participate in monthly project review meetings to evaluate performance against profit-sharing targets.<\/p>\n<\/li>\n<\/ul>\n<\/li>\n<\/ul>\n<h3>Required Qualifications<\/h3>\n<ul>\n<li>\n<p><strong>Experience:<\/strong> Minimum <strong>5 years<\/strong> managing heavy highway asphalt projects (paving, milling, overlays).<\/p>\n<\/li>\n<li>\n<p><strong>Technical Knowledge:<\/strong><\/p>\n<ul>\n<li>\n<p>Proficient in asphalt mix design, compaction techniques, and equipment operation (pavers, rollers, milling machines).<\/p>\n<\/li>\n<li>\n<p>Familiarity with state DOT specifications and ASTM testing procedures.<\/p>\n<\/li>\n<\/ul>\n<\/li>\n<li>\n<p><strong>Project Management Skills:<\/strong><\/p>\n<ul>\n<li>\n<p>Strong scheduling, budgeting, and resource-allocation capabilities.<\/p>\n<\/li>\n<li>\n<p>Comfortable using construction management software (e.g., Procore, HCSS HeavyBid).<\/p>\n<\/li>\n<\/ul>\n<\/li>\n<li>\n<p><strong>Leadership &amp; Communication:<\/strong><\/p>\n<ul>\n<li>\n<p>Excellent interpersonal skills; able to lead crews and negotiate with vendors.<\/p>\n<\/li>\n<li>\n<p>Clear, concise report writing and presentation abilities.<\/p>\n<\/li>\n<\/ul>\n<\/li>\n<li>\n<p><strong>Certifications (preferred):<\/strong><\/p>\n<ul>\n<li>\n<p>OSHA 30-Hour Construction Safety<\/p>\n<\/li>\n<li>\n<p>AASHTO Quality Technician (Level I or II)<\/p>\n<\/li>\n<li>\n<p>PMP or CCM credential<\/p><\/li><\/ul><\/li><\/ul>","%category%":"Management","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/e7d7872088e9-paving-project-manager","%breezy_id%":"e7d7872088e9","%breezy_friendly_id%":"e7d7872088e9-paving-project-manager","%breezy_created_date%":"2025-05-15T19:54:31.959Z","%breezy_updated_date%":"2026-01-14T19:23:50.964Z","%_wpgmp_location_city%":"Charleston","%_wpgmp_location_state%":"SC","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Charleston, SC, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"32.7833163","%_wpgmp_metabox_longitude%":"-79.9319664","%rank_math_internal_links_processed%":"1"}},"id":2446,"infowindow_disable":false},{"source":"post","title":"Electrical Control Technician","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Electrical Control Technician\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    POSITION SUMMARY:&nbsp; To perform electrical and instrumentation inspections, repairs and rebuilds on all plant operating equipment to ensure continuous operation&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/electrical-control-technician\/\" name=\"Electrical Control Technician\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"POSITION SUMMARY:&nbsp; To perform electrical and instrumentation inspections, repairs and rebuilds on all plant operating equipment to ensure continuous operation&hellip;","address":"Salinas, CA, USA","location":{"lat":"36.6777372","city":"Salinas","state":"CA","country":"United States","lng":"-121.6555013","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/electrical-control-technician\/","zoom":19,"extra_fields":{"post_excerpt":"POSITION SUMMARY:&nbsp; To perform electrical and instrumentation inspections, repairs and rebuilds on all plant operating equipment to ensure continuous operation&hellip;","post_content":"<p><strong>POSITION SUMMARY:&nbsp; <\/strong>To perform electrical and instrumentation inspections, repairs and rebuilds on all plant operating equipment to ensure continuous operation within the required quality control standards. This role is critical to achieving Plant OEE and Equipment Availability goals by elimination of unplanned stops and extended downtimes. Incumbents in the position are required to participate in company-sponsored training and certification programs to ensure that their job knowledge and skills meet evolving company standards.<\/p>\n<p><strong>RESPONSIBILITIES &amp; EXPECTATIONS: <\/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>Be able to perform preventive maintenance checks and report findings (both verbally and in writing)<\/li><li>Participate in the work order initiation process when required<\/li><li>Ensure all inventory parts are correctly charged from Stores and assist with procurement of parts used as per LNA procedures<\/li><li>Possess a good knowledge of power distribution systems<\/li><li>Be able to perform low voltage and high voltage terminations<\/li><li>Have some experience and\/or willingness &amp; ability to learn performing maintenance on switchgear up to 2300 volts.<\/li><li>Knowledge of low, medium and high voltage switching applications.<\/li><li>Experience with motor ground testing and record keeping in Microsoft Excel.<\/li><li>Experience with Windows OS and Microsoft Office programs. AutoCAD and SAP experience preferred but not required.<\/li><li>Experience in troubleshooting and maintaining all types of motor control circuits.<\/li><li>Perform basic electrical calculations<\/li><li>Perform tasks with all electrical test equipment (volt meters, meggers, current generators, loop calibrators, etc)<\/li><li>Experience to fabricate and install conduit<\/li><li>Perform soldering operations<\/li><li>Experience in testing, troubleshooting and repairing AC\/DC motors and drives<\/li><li>Install and align electrical motors<\/li><li>Experience troubleshooting and maintaining air dryers<\/li><li>Experience in calibrating, troubleshooting and maintaining belt-weighing devices<\/li><li>Experience maintaining and replacing&nbsp; process control circuits including control valves, actuators and positioners<\/li><li>Should possess some knowledge of the CMMS System and be willing to correctly complete work orders and checklist including signing and dating<\/li><li>Be familiar with thermography and fully understand the uses<\/li><li>Experience to perform troubleshooting and repairs on Gas Analyzers<\/li><li>Experience to troubleshoot and maintain variable speed drives<\/li><\/ul>\n<p><\/p>\n<p><strong>ATTRIBUTES: What are the Essential Knowledge\/Skills\/Abilities for this position? <\/strong><\/p>\n<p><\/p>\n<ul><li>Capable of working any shift, overtime, be on-call, or work seven days a week, if needed.<\/li><li>Multi task with a strong sense of urgency to meet the customer needs.<\/li><li>Work well within a team environment and take instructions from management and co-workers.&nbsp;<\/li><li>Self-starter with the ability to work independently.<\/li><li>Must possess the basic reading and math skills.<\/li><li>Good written and verbal communication skills.<\/li><li>Have basic computer skills on how to use MS Office products and SAP.<\/li><li>Strong record of attendance reliability.<\/li><li>Understand and observe all department and plant safety rules and maintain a high level of housekeeping in assigned work areas.<\/li><li>Perform the essential job duties required of this job.<\/li><\/ul>\n<p><\/p>\n<p><strong>Physical Demands include, but are not limited to:<\/strong><\/p>\n<ul><li>Must be physically able to perform work assigned.<\/li><li>Must be physically capable of accessing all plant locations.<\/li><li>Access all areas within a site which could include heights of 150 feet, confined spaces, climbing ladders or stairs, and accessing tunnels.<\/li><li>Will be working at times in covered environment but mainly in a lime\/mineral environment.<\/li><li>The employee will be exposed to the following working conditions:&nbsp; Extreme Heat and Cold, Noise, Vibration, Oils, and Atmospheric Conditions such as Dust, Fumes, and Lime\/Mineral Particles.<\/li><li>The employee will be required to perform the following actions (from time to time): Standing, walking, balancing, stooping, kneeling, reaching, talking, seeing, hearing and sitting.<\/li><li>Ability to occasionally lift\/carry 50 pounds.<\/li><\/ul>\n<p><\/p>\n<p><strong>Required Experience: <\/strong>Five (5) to Seven (7) years electrical experience. Completion of an apprenticeship program, technical program, or equivalent experience in industrial background.<\/p>\n<p><strong>Preferred Experience: <\/strong>Previous heavy manufacturing and\/or mining experience is highly preferred.<\/p>\n<p><strong>Required Education:&nbsp; <\/strong>High School Diploma or GED equivalent.<\/p>\n<p><strong>Preferred Education: &nbsp;<\/strong>Current Journeyman license.<\/p>","post_title":"Electrical Control Technician","post_link":"https:\/\/turnerstaffing.com\/position\/electrical-control-technician\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Mid Level","%location_country%":"United States","%location_city%":"Salinas","%location_state_id%":"CA","%location_state_name%":"California","%location_city_state%":"Salinas, CA","%education%":"High School or Equivalent","%department%":"","%description%":"<p><strong>POSITION SUMMARY:&nbsp; <\/strong>To perform electrical and instrumentation inspections, repairs and rebuilds on all plant operating equipment to ensure continuous operation within the required quality control standards. This role is critical to achieving Plant OEE and Equipment Availability goals by elimination of unplanned stops and extended downtimes. Incumbents in the position are required to participate in company-sponsored training and certification programs to ensure that their job knowledge and skills meet evolving company standards.<\/p>\n<p><strong>RESPONSIBILITIES &amp; EXPECTATIONS: <\/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>Be able to perform preventive maintenance checks and report findings (both verbally and in writing)<\/li><li>Participate in the work order initiation process when required<\/li><li>Ensure all inventory parts are correctly charged from Stores and assist with procurement of parts used as per LNA procedures<\/li><li>Possess a good knowledge of power distribution systems<\/li><li>Be able to perform low voltage and high voltage terminations<\/li><li>Have some experience and\/or willingness &amp; ability to learn performing maintenance on switchgear up to 2300 volts.<\/li><li>Knowledge of low, medium and high voltage switching applications.<\/li><li>Experience with motor ground testing and record keeping in Microsoft Excel.<\/li><li>Experience with Windows OS and Microsoft Office programs. AutoCAD and SAP experience preferred but not required.<\/li><li>Experience in troubleshooting and maintaining all types of motor control circuits.<\/li><li>Perform basic electrical calculations<\/li><li>Perform tasks with all electrical test equipment (volt meters, meggers, current generators, loop calibrators, etc)<\/li><li>Experience to fabricate and install conduit<\/li><li>Perform soldering operations<\/li><li>Experience in testing, troubleshooting and repairing AC\/DC motors and drives<\/li><li>Install and align electrical motors<\/li><li>Experience troubleshooting and maintaining air dryers<\/li><li>Experience in calibrating, troubleshooting and maintaining belt-weighing devices<\/li><li>Experience maintaining and replacing&nbsp; process control circuits including control valves, actuators and positioners<\/li><li>Should possess some knowledge of the CMMS System and be willing to correctly complete work orders and checklist including signing and dating<\/li><li>Be familiar with thermography and fully understand the uses<\/li><li>Experience to perform troubleshooting and repairs on Gas Analyzers<\/li><li>Experience to troubleshoot and maintain variable speed drives<\/li><\/ul>\n<p><\/p>\n<p><strong>ATTRIBUTES: What are the Essential Knowledge\/Skills\/Abilities for this position? <\/strong><\/p>\n<p><\/p>\n<ul><li>Capable of working any shift, overtime, be on-call, or work seven days a week, if needed.<\/li><li>Multi task with a strong sense of urgency to meet the customer needs.<\/li><li>Work well within a team environment and take instructions from management and co-workers.&nbsp;<\/li><li>Self-starter with the ability to work independently.<\/li><li>Must possess the basic reading and math skills.<\/li><li>Good written and verbal communication skills.<\/li><li>Have basic computer skills on how to use MS Office products and SAP.<\/li><li>Strong record of attendance reliability.<\/li><li>Understand and observe all department and plant safety rules and maintain a high level of housekeeping in assigned work areas.<\/li><li>Perform the essential job duties required of this job.<\/li><\/ul>\n<p><\/p>\n<p><strong>Physical Demands include, but are not limited to:<\/strong><\/p>\n<ul><li>Must be physically able to perform work assigned.<\/li><li>Must be physically capable of accessing all plant locations.<\/li><li>Access all areas within a site which could include heights of 150 feet, confined spaces, climbing ladders or stairs, and accessing tunnels.<\/li><li>Will be working at times in covered environment but mainly in a lime\/mineral environment.<\/li><li>The employee will be exposed to the following working conditions:&nbsp; Extreme Heat and Cold, Noise, Vibration, Oils, and Atmospheric Conditions such as Dust, Fumes, and Lime\/Mineral Particles.<\/li><li>The employee will be required to perform the following actions (from time to time): Standing, walking, balancing, stooping, kneeling, reaching, talking, seeing, hearing and sitting.<\/li><li>Ability to occasionally lift\/carry 50 pounds.<\/li><\/ul>\n<p><\/p>\n<p><strong>Required Experience: <\/strong>Five (5) to Seven (7) years electrical experience. Completion of an apprenticeship program, technical program, or equivalent experience in industrial background.<\/p>\n<p><strong>Preferred Experience: <\/strong>Previous heavy manufacturing and\/or mining experience is highly preferred.<\/p>\n<p><strong>Required Education:&nbsp; <\/strong>High School Diploma or GED equivalent.<\/p>\n<p><strong>Preferred Education: &nbsp;<\/strong>Current Journeyman license.<\/p>","%category%":"Other","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/ab307c68f717-electrical-control-technician","%breezy_id%":"ab307c68f717","%breezy_friendly_id%":"ab307c68f717-electrical-control-technician","%breezy_created_date%":"2025-05-14T23:32:37.204Z","%breezy_updated_date%":"2025-11-14T20:40:43.738Z","%_wpgmp_location_city%":"Salinas","%_wpgmp_location_state%":"CA","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Salinas, CA, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"36.6777372","%_wpgmp_metabox_longitude%":"-121.6555013","%rank_math_internal_links_processed%":"1"}},"id":2439,"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-3\/\" 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":"Crane, TX, USA","location":{"lat":"31.3973624","city":"Crane","state":"TX","country":"United States","lng":"-102.3501419","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/haul-truck-driver-mining-3\/","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-3\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"","%location_country%":"United States","%location_city%":"Crane","%location_state_id%":"TX","%location_state_name%":"Texas","%location_city_state%":"Crane, TX","%education%":"","%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%":"","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/d46e203d8867-haul-truck-driver-mining","%breezy_id%":"d46e203d8867","%breezy_friendly_id%":"d46e203d8867-haul-truck-driver-mining","%breezy_created_date%":"2022-10-31T13:58:37.327Z","%breezy_updated_date%":"2025-11-14T20:41:36.516Z","%_wpgmp_location_city%":"Crane","%_wpgmp_location_state%":"TX","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Crane, TX, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"31.3973624","%_wpgmp_metabox_longitude%":"-102.3501419","%rank_math_internal_links_processed%":"1"}},"id":2372,"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><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":"Drill Operator &#8211; Mining","post_link":"https:\/\/turnerstaffing.com\/position\/drill-operator-mining\/","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%":"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><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\/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-09-04T14:04:11.748Z","%_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":"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-11-14T20:43:07.026Z","%_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":"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-11-14T20:44:14.417Z","%_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%":"2026-01-14T17:29:40.243Z","%_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-11-14T20:43:35.996Z","%_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":"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-11-14T20:44:16.501Z","%_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":"Senior Mining Electrician","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Senior Mining Electrician\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Job Description: A senior electrician in mining is&nbsp;responsible for installing, maintaining, and repairing complex electrical systems and equipment in mines,&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/mine-electrician\/\" name=\"Senior Mining Electrician\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Job Description: A senior electrician in mining is&nbsp;responsible for installing, maintaining, and repairing complex electrical systems and equipment in mines,&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: A senior electrician in mining is&nbsp;responsible for installing, maintaining, and repairing complex electrical systems and equipment in mines,&hellip;","post_content":"<p><strong>Job Description:<\/strong><\/p>\n<ul><li>A senior electrician in mining is&nbsp;responsible for installing, maintaining, and repairing complex electrical systems and equipment in mines, which includes a focus on troubleshooting, safety, and potentially leading projects. May act as a lead worker, supervising junior electricians or contributing to the design and implementation of new electrical systems.&nbsp; Key duties involve working on heavy machinery, power distribution, and safety systems, often in challenging and hazardous environments like those found underground or in surface operations.&nbsp;This role requires strong problem-solving skills, electrical knowledge, physical endurance, and the ability to work in tight spaces and varied conditions.&nbsp;<\/li><\/ul>\n<p><strong>Job Requirements:<\/strong><\/p>\n<ul><li>Must have reasonable knowledge of electrical code and installation procedures.<\/li><li>Diagnose and resolve complex electrical malfunctions in various systems and equipment, from surface mines to underground operations.&nbsp;<\/li><li>Excellent critical thinking and troubleshooting skills are essential for identifying and fixing issues in complex systems.<\/li><li>Previous experience in 2400V; 480 \u2013 3 phase motor controls and system operation.<\/li><li>Knowledge of PLC systems and programming<\/li><li>Able to read electrical blueprints.<\/li><li>Hold a Journeymen Electrician card preferred.<\/li><li>Must have a minimum of 4 years of experience as an Industrial Electrician or 12 months as a Senior Electrician at a mine site<\/li><li>Troubleshoot effectively with a minimum of supervision.    &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<\/li><li>Applicants are required to furnish their own hand tools.<\/li><li>Experience in mining is helpful.<\/li><li>Must be thoroughly familiar with all aspects of safety in the electrical field.&nbsp;<\/li><li>Capable of working with a minimum of supervision.<\/li><li>All work described above to be done in an efficient and workman-like manner.&nbsp;<\/li><li>Any knowledge of welding and fabrication is a plus but not required.<\/li><li>Ensure all work is done safely and in compliance with strict mining regulations and standards, which may include working with specialized safety equipment.&nbsp;<\/li><li>Applicant is responsible for the housekeeping and cleanup around his work area.<\/li><li>Additional duties are required as assigned by management.&nbsp;<\/li><\/ul>","post_title":"Senior Mining 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><strong>Job Description:<\/strong><\/p>\n<ul><li>A senior electrician in mining is&nbsp;responsible for installing, maintaining, and repairing complex electrical systems and equipment in mines, which includes a focus on troubleshooting, safety, and potentially leading projects. May act as a lead worker, supervising junior electricians or contributing to the design and implementation of new electrical systems.&nbsp; Key duties involve working on heavy machinery, power distribution, and safety systems, often in challenging and hazardous environments like those found underground or in surface operations.&nbsp;This role requires strong problem-solving skills, electrical knowledge, physical endurance, and the ability to work in tight spaces and varied conditions.&nbsp;<\/li><\/ul>\n<p><strong>Job Requirements:<\/strong><\/p>\n<ul><li>Must have reasonable knowledge of electrical code and installation procedures.<\/li><li>Diagnose and resolve complex electrical malfunctions in various systems and equipment, from surface mines to underground operations.&nbsp;<\/li><li>Excellent critical thinking and troubleshooting skills are essential for identifying and fixing issues in complex systems.<\/li><li>Previous experience in 2400V; 480 \u2013 3 phase motor controls and system operation.<\/li><li>Knowledge of PLC systems and programming<\/li><li>Able to read electrical blueprints.<\/li><li>Hold a Journeymen Electrician card preferred.<\/li><li>Must have a minimum of 4 years of experience as an Industrial Electrician or 12 months as a Senior Electrician at a mine site<\/li><li>Troubleshoot effectively with a minimum of supervision.    &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<\/li><li>Applicants are required to furnish their own hand tools.<\/li><li>Experience in mining is helpful.<\/li><li>Must be thoroughly familiar with all aspects of safety in the electrical field.&nbsp;<\/li><li>Capable of working with a minimum of supervision.<\/li><li>All work described above to be done in an efficient and workman-like manner.&nbsp;<\/li><li>Any knowledge of welding and fabrication is a plus but not required.<\/li><li>Ensure all work is done safely and in compliance with strict mining regulations and standards, which may include working with specialized safety equipment.&nbsp;<\/li><li>Applicant is responsible for the housekeeping and cleanup around his work area.<\/li><li>Additional duties are required as assigned by management.&nbsp;<\/li><\/ul>","%category%":"","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/9c0b376c6bbc-senior-mining-electrician","%breezy_id%":"9c0b376c6bbc","%breezy_friendly_id%":"9c0b376c6bbc-senior-mining-electrician","%breezy_created_date%":"2024-11-14T16:24:57.526Z","%breezy_updated_date%":"2026-01-08T15:55:27.839Z","%_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","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    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\" 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.4482948","city":"Phoenix","state":"AZ","country":"United States","lng":"-112.0725488","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","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","%breezy_id%":"6eefa39a14e4","%breezy_friendly_id%":"6eefa39a14e4-maintenance-mechanic","%breezy_created_date%":"2024-11-01T17:33:37.970Z","%breezy_updated_date%":"2025-11-14T20:42:56.226Z","%_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.4482948","%_wpgmp_metabox_longitude%":"-112.0725488","%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-11-14T20:42:57.253Z","%_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-11-14T20:42:35.998Z","%_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%":"2026-01-14T19:23:16.694Z","%_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.4482948","city":"Phoenix","state":"AZ","country":"United States","lng":"-112.0725488","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-11-14T20:41:10.688Z","%_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.4482948","%_wpgmp_metabox_longitude%":"-112.0725488","%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.4482948","city":"Phoenix","state":"AZ","country":"United States","lng":"-112.0725488","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-11-14T20:41:17.839Z","%_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.4482948","%_wpgmp_metabox_longitude%":"-112.0725488","%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-11-14T20:41:16.633Z","%_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":"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-11-14T20:42:50.312Z","%_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":"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-11-14T20:42:41.287Z","%_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":"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-11-14T20:41:54.073Z","%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\"]"}}