Job Board

{"map_options":{"center_lat":"29.7600771","center_lng":"-95.3701108","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":"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-2\/\" 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-2\/","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-2\/","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%":"2025-08-12T17:43:42.488Z","%_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":2685,"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 Southwest Texas (West Texas, New Mexico and Arizona) who will be based out of Dallas&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 Southwest Texas (West Texas, New Mexico and Arizona) who will be based out of Dallas&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\/business-development-manager\/","zoom":19,"extra_fields":{"post_excerpt":"The Business Development Manager for Southwest Texas (West Texas, New Mexico and Arizona) who will be based out of Dallas&hellip;","post_content":"<p>The <strong>Business Development Manager for Southwest Texas (West Texas, New Mexico and Arizona) who will be based out of Dallas and<\/strong> 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%":"Dallas","%location_state_id%":"TX","%location_state_name%":"Texas","%location_city_state%":"Dallas, TX","%education%":"Bachelor's Degree","%department%":"","%description%":"<p>The <strong>Business Development Manager for Southwest Texas (West Texas, New Mexico and Arizona) who will be based out of Dallas and<\/strong> 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\/5583792874b9-business-development-manager","%breezy_id%":"5583792874b9","%breezy_friendly_id%":"5583792874b9-business-development-manager","%breezy_created_date%":"2025-08-12T17:39:45.914Z","%breezy_updated_date%":"2025-08-12T17:40:53.399Z","%_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":2684,"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":"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\/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%":"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 - 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\/ea6f937120af-operations-superintendent-mining","%breezy_id%":"ea6f937120af","%breezy_friendly_id%":"ea6f937120af-operations-superintendent-mining","%breezy_created_date%":"2025-08-11T20:24:22.193Z","%breezy_updated_date%":"2025-08-11T20:25:10.274Z","%_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":2683,"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-08-15T14:59:04.196Z","%_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":"Field Service Technician","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Field Service Technician\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    KEY RESPONSIBILITIES \u2022 Perform field service troubleshooting and diagnosing, timely repairs, and component installation on all makes and models of&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/field-service-technician\/\" name=\"Field Service Technician\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"KEY RESPONSIBILITIES \u2022 Perform field service troubleshooting and diagnosing, timely repairs, and component installation on all makes and models of&hellip;","address":"Pasco, WA, USA","location":{"lat":"46.2305049","city":"Pasco","state":"WA","country":"United States","lng":"-119.0922316","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/field-service-technician\/","zoom":19,"extra_fields":{"post_excerpt":"KEY RESPONSIBILITIES \u2022 Perform field service troubleshooting and diagnosing, timely repairs, and component installation on all makes and models of&hellip;","post_content":"<p>KEY RESPONSIBILITIES<\/p>\n<p>\u2022 Perform field service troubleshooting and diagnosing, timely repairs, and component installation on all makes and<\/p>\n<p>models of our client's&nbsp;equipment.<\/p>\n<p>\u2022 Diagnose faults or malfunctions to determine required repairs using engine diagnostic equipment such as<\/p>\n<p>computerized test equipment and calibration devices.<\/p>\n<p>\u2022 Working knowledge of reading blueprints, wiring diagrams, schematic drawings, or engineering instructions for<\/p>\n<p>assembling electronic units.<\/p>\n<p>\u2022 Test electrical units, analyze results to evaluate performance and determine need for adjustment.<\/p>\n<p>\u2022 Test mechanical products and equipment after repair or assembly to ensure proper performance and compliance<\/p>\n<p>with manufacturer's specifications.<\/p>\n<p>\u2022 Manage and maintain all aspects of the customer relationship through open communication and timely follow-up.<\/p>\n<p>\u2022 Provide customer support and education, working with users to identify needs, determine sources of problems, or<\/p>\n<p>to provide information on product use.<\/p>\n<p>\u2022 Troubleshoot issues and concerns, partnering with other departments and leadership as necessary.<\/p>\n<p>\u2022 Research, order, and maintain parts inventory for services and repairs.<\/p>\n<p>\u2022 Read and understand operating manuals, blueprints, and technical drawings.<\/p>\n<p>\u2022 Maintains condition of mobile service vehicle, parts inventory, tools, and equipment.<\/p>\n<p>\u2022 Follow all safety rules and regulations while performing work assignments and adhere to all policies and<\/p>\n<p>procedures as specified in company work rules.<\/p>\n<p>OTHER RESPONSIBILITIES<\/p>\n<p>\u2022 All other duties as assigned by supervisor\/manager<\/p>\n<p>ABILITIES<\/p>\n<p>\u2022 Demonstrates our client\u2019s values of Harmony, Fairness and Generosity.<\/p>\n<p>\u2022 Ability to travel up to 75% of the time (estimated at 3 weeks a month).<\/p>\n<p>\u2022 Strong communication skills both orally and written, at all levels of the organization.<\/p>\n<p>\u2022 General computer skills \u2013 proficiency with Word, Excel, PowerPoint, Outlook and file sharing preferred.<\/p>\n<p>\u2022 Basic mathematical skills (add\/subtract\/multiply\/divide and work with decimals and fractions).<\/p>\n<p>\u2022 Ability to read and interpret documents, including, but not limited to blueprints, operating and maintenance<\/p>\n<p>instructions and procedural manuals.<\/p>\n<p>\u2022 Capacity to manage and prioritize multiple tasks\/projects while meeting deadlines and managing time effectively.<\/p>\n<p>\u2022 Ability to exercise sound judgement and make decisions in a manner consistent with company policies, practices,<\/p>\n<p>and culture.<\/p>\n<p>\u2022 Ability to drive and accept change while being creative and forward-thinking.<\/p>\n<p>\u2022 Ability to solve practical problems and deal with a variety of concrete variables in situations where only limited<\/p>\n<p>standardization exists.<\/p>\n<p>\u2022 Ability to maintain high levels of confidentiality and trust.<\/p>\n<p>\u2022 Ability to work independently as well as in a team environment.<\/p>\n<p>\u2022 Working knowledge of hydraulics, pneumatics, diesel engines, electrical, fuel and other systems is preferred.<\/p>\n<p>\u2022 Capable of meeting and maintaining health and safety guidelines while keeping work area in a clean and orderly<\/p>\n<p>fashion.<\/p>\n<p>\u2022 Working conditions include office and professional as well as work including industrial environments as well as<\/p>\n<p>outside temperatures and all-weather conditions.<\/p>\n<p>QUALIFICATIONS<\/p>\n<p>\u2022 Two-year technical school degree in Diesel\/Heavy Equipment or related field and\/or at least three years or more<\/p>\n<p>of mechanical experience is preferred.<\/p>\n<p>\u2022 Working knowledge of hydraulics, pneumatics, diesel engines, fuel and other systems is preferred.<\/p>\n<p>\u2022 Must have the ability to obtain or carry a Class A CDL and DOT health card, with a clean driving record<\/p>\n<p>\u2022 Must have excellent communication skills, both written and verbal and the ability to establish and maintain<\/p>\n<p>effective working relationships at all levels of the organization<\/p>\n<p>\u2022 Demonstrated excellent work-ethic with self-motivation, ability to work safe with no supervision on customer job<\/p>\n<p>sites, while maintaining company and customer expectations of thoroughness and customer service<\/p>\n<p>\u2022 Ability to read and follow intermediate measurements, schematics, and technical documentation<\/p>\n<p>\u2022 Basic computer skills required using Microsoft Office Suite programs and file sharing<\/p>","post_title":"Field Service Technician","post_link":"https:\/\/turnerstaffing.com\/position\/field-service-technician\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Mid Level","%location_country%":"United States","%location_city%":"Pasco","%location_state_id%":"WA","%location_state_name%":"Washington","%location_city_state%":"Pasco, WA","%education%":"High School or Equivalent","%department%":"","%description%":"<p>KEY RESPONSIBILITIES<\/p>\n<p>\u2022 Perform field service troubleshooting and diagnosing, timely repairs, and component installation on all makes and<\/p>\n<p>models of our client's&nbsp;equipment.<\/p>\n<p>\u2022 Diagnose faults or malfunctions to determine required repairs using engine diagnostic equipment such as<\/p>\n<p>computerized test equipment and calibration devices.<\/p>\n<p>\u2022 Working knowledge of reading blueprints, wiring diagrams, schematic drawings, or engineering instructions for<\/p>\n<p>assembling electronic units.<\/p>\n<p>\u2022 Test electrical units, analyze results to evaluate performance and determine need for adjustment.<\/p>\n<p>\u2022 Test mechanical products and equipment after repair or assembly to ensure proper performance and compliance<\/p>\n<p>with manufacturer's specifications.<\/p>\n<p>\u2022 Manage and maintain all aspects of the customer relationship through open communication and timely follow-up.<\/p>\n<p>\u2022 Provide customer support and education, working with users to identify needs, determine sources of problems, or<\/p>\n<p>to provide information on product use.<\/p>\n<p>\u2022 Troubleshoot issues and concerns, partnering with other departments and leadership as necessary.<\/p>\n<p>\u2022 Research, order, and maintain parts inventory for services and repairs.<\/p>\n<p>\u2022 Read and understand operating manuals, blueprints, and technical drawings.<\/p>\n<p>\u2022 Maintains condition of mobile service vehicle, parts inventory, tools, and equipment.<\/p>\n<p>\u2022 Follow all safety rules and regulations while performing work assignments and adhere to all policies and<\/p>\n<p>procedures as specified in company work rules.<\/p>\n<p>OTHER RESPONSIBILITIES<\/p>\n<p>\u2022 All other duties as assigned by supervisor\/manager<\/p>\n<p>ABILITIES<\/p>\n<p>\u2022 Demonstrates our client\u2019s values of Harmony, Fairness and Generosity.<\/p>\n<p>\u2022 Ability to travel up to 75% of the time (estimated at 3 weeks a month).<\/p>\n<p>\u2022 Strong communication skills both orally and written, at all levels of the organization.<\/p>\n<p>\u2022 General computer skills \u2013 proficiency with Word, Excel, PowerPoint, Outlook and file sharing preferred.<\/p>\n<p>\u2022 Basic mathematical skills (add\/subtract\/multiply\/divide and work with decimals and fractions).<\/p>\n<p>\u2022 Ability to read and interpret documents, including, but not limited to blueprints, operating and maintenance<\/p>\n<p>instructions and procedural manuals.<\/p>\n<p>\u2022 Capacity to manage and prioritize multiple tasks\/projects while meeting deadlines and managing time effectively.<\/p>\n<p>\u2022 Ability to exercise sound judgement and make decisions in a manner consistent with company policies, practices,<\/p>\n<p>and culture.<\/p>\n<p>\u2022 Ability to drive and accept change while being creative and forward-thinking.<\/p>\n<p>\u2022 Ability to solve practical problems and deal with a variety of concrete variables in situations where only limited<\/p>\n<p>standardization exists.<\/p>\n<p>\u2022 Ability to maintain high levels of confidentiality and trust.<\/p>\n<p>\u2022 Ability to work independently as well as in a team environment.<\/p>\n<p>\u2022 Working knowledge of hydraulics, pneumatics, diesel engines, electrical, fuel and other systems is preferred.<\/p>\n<p>\u2022 Capable of meeting and maintaining health and safety guidelines while keeping work area in a clean and orderly<\/p>\n<p>fashion.<\/p>\n<p>\u2022 Working conditions include office and professional as well as work including industrial environments as well as<\/p>\n<p>outside temperatures and all-weather conditions.<\/p>\n<p>QUALIFICATIONS<\/p>\n<p>\u2022 Two-year technical school degree in Diesel\/Heavy Equipment or related field and\/or at least three years or more<\/p>\n<p>of mechanical experience is preferred.<\/p>\n<p>\u2022 Working knowledge of hydraulics, pneumatics, diesel engines, fuel and other systems is preferred.<\/p>\n<p>\u2022 Must have the ability to obtain or carry a Class A CDL and DOT health card, with a clean driving record<\/p>\n<p>\u2022 Must have excellent communication skills, both written and verbal and the ability to establish and maintain<\/p>\n<p>effective working relationships at all levels of the organization<\/p>\n<p>\u2022 Demonstrated excellent work-ethic with self-motivation, ability to work safe with no supervision on customer job<\/p>\n<p>sites, while maintaining company and customer expectations of thoroughness and customer service<\/p>\n<p>\u2022 Ability to read and follow intermediate measurements, schematics, and technical documentation<\/p>\n<p>\u2022 Basic computer skills required using Microsoft Office Suite programs and file sharing<\/p>","%category%":"Operations","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/c8a07f9fa46c-field-service-technician","%breezy_id%":"c8a07f9fa46c","%breezy_friendly_id%":"c8a07f9fa46c-field-service-technician","%breezy_created_date%":"2025-06-18T15:48:03.314Z","%breezy_updated_date%":"2025-08-08T17:38:57.271Z","%_wpgmp_location_city%":"Pasco","%_wpgmp_location_state%":"WA","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Pasco, WA, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"46.2305049","%_wpgmp_metabox_longitude%":"-119.0922316","%rank_math_internal_links_processed%":"1"}},"id":2681,"infowindow_disable":false},{"source":"post","title":"Security Technician","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Security Technician\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Our client is currently recruiting Security Technicians for immediate openings in the Davenport, Iowa City, and Cedar Rapids, IA areas.&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/security-technician-2\/\" name=\"Security Technician\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Our client is currently recruiting Security Technicians for immediate openings in the Davenport, Iowa City, and Cedar Rapids, IA areas.&hellip;","address":"Iowa City, IA, USA","location":{"lat":"41.6578257","city":"Iowa City","state":"IA","country":"United States","lng":"-91.5346169","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/security-technician-2\/","zoom":19,"extra_fields":{"post_excerpt":"Our client is currently recruiting Security Technicians for immediate openings in the Davenport, Iowa City, and Cedar Rapids, IA areas.&hellip;","post_content":"<p>Our client is currently recruiting Security Technicians for immediate openings in the Davenport, Iowa City, and Cedar Rapids, IA areas.<\/p>\n<p>Main duties include programming &amp; installation of security systems on large construction, new construction, and remodeling projects.<\/p>\n<p>Required:<\/p>\n\n<ul><li>Completed Low Voltage Electrical apprenticeship through IBEW or Technical School<\/li><li>Minimum of 1 Year experience with installation and programming of Security systems, VMS software<\/li><li>Low voltage knowledge and experience pulling and routing wires<\/li><li>Reliable transportation<\/li><li>The ability to follow directions, climb ladders, and lift up to 50lbs repetitively.&nbsp;<\/li><\/ul><p><\/p>","post_title":"Security Technician","post_link":"https:\/\/turnerstaffing.com\/position\/security-technician-2\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Mid Level","%location_country%":"United States","%location_city%":"Iowa City","%location_state_id%":"IA","%location_state_name%":"Iowa","%location_city_state%":"Iowa City, IA","%education%":"Unspecified","%department%":"","%description%":"<p>Our client is currently recruiting Security Technicians for immediate openings in the Davenport, Iowa City, and Cedar Rapids, IA areas.<\/p>\n<p>Main duties include programming &amp; installation of security systems on large construction, new construction, and remodeling projects.<\/p>\n<p>Required:<\/p>\n\n<ul><li>Completed Low Voltage Electrical apprenticeship through IBEW or Technical School<\/li><li>Minimum of 1 Year experience with installation and programming of Security systems, VMS software<\/li><li>Low voltage knowledge and experience pulling and routing wires<\/li><li>Reliable transportation<\/li><li>The ability to follow directions, climb ladders, and lift up to 50lbs repetitively.&nbsp;<\/li><\/ul><p><\/p>","%category%":"Operations","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/1c45017eb8bc-security-technician","%breezy_id%":"1c45017eb8bc","%breezy_friendly_id%":"1c45017eb8bc-security-technician","%breezy_created_date%":"2025-08-05T11:43:48.630Z","%breezy_updated_date%":"2025-08-05T11:48:41.890Z","%_wpgmp_location_city%":"Iowa City","%_wpgmp_location_state%":"IA","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Iowa City, IA, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"41.6578257","%_wpgmp_metabox_longitude%":"-91.5346169","%rank_math_internal_links_processed%":"1"}},"id":2677,"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-08-05T16:01:59.710Z","%_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    Turner Mining Group \u2013 Haul Truck Driver Turner Mining Group is committed to changing the way mining companies do business.&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/haul-truck-driver-10\/\" 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 Turner Mining Group is committed to changing the way mining companies do business.&hellip;","address":"Crawford, TX, USA","location":{"lat":"31.5343308","city":"Crawford","state":"TX","country":"United States","lng":"-97.44307","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/haul-truck-driver-10\/","zoom":19,"extra_fields":{"post_excerpt":"Turner Mining Group \u2013 Haul Truck Driver Turner Mining Group is committed to changing the way mining companies do business.&hellip;","post_content":"<p><strong><u>Turner Mining Group \u2013 Haul Truck Driver<\/u><\/strong><\/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!<\/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-10\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Entry Level","%location_country%":"United States","%location_city%":"Crawford","%location_state_id%":"TX","%location_state_name%":"Texas","%location_city_state%":"Crawford, TX","%education%":"Unspecified","%department%":"Operations","%description%":"<p><strong><u>Turner Mining Group \u2013 Haul Truck Driver<\/u><\/strong><\/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!<\/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\/9f3322a8dd0e-haul-truck-driver","%breezy_id%":"9f3322a8dd0e","%breezy_friendly_id%":"9f3322a8dd0e-haul-truck-driver","%breezy_created_date%":"2025-06-09T21:14:12.737Z","%breezy_updated_date%":"2025-08-05T13:58:14.138Z","%_wpgmp_location_city%":"Crawford","%_wpgmp_location_state%":"TX","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Crawford, TX, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"31.5343308","%_wpgmp_metabox_longitude%":"-97.44307","%rank_math_internal_links_processed%":"1"}},"id":2675,"infowindow_disable":false},{"source":"post","title":"Licensed A&amp;P Mechanic &#8211; Heavy Maintenance","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Licensed A&amp;P Mechanic &#8211; Heavy Maintenance\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Services, troubleshoots, repairs, modifies, preserves, maintains, and overhauls aircraft, aircraft systems, and aircraft components in accordance with policies, procedures, requirements,&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/licensed-ap-mechanic-heavy-maintenance-4\/\" name=\"Licensed A&amp;P Mechanic &#8211; Heavy Maintenance\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Services, troubleshoots, repairs, modifies, preserves, maintains, and overhauls aircraft, aircraft systems, and aircraft components in accordance with policies, procedures, requirements,&hellip;","address":"Limestone, ME, USA","location":{"lat":"46.9086023","city":"Limestone","state":"ME","country":"United States","lng":"-67.825816","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/licensed-ap-mechanic-heavy-maintenance-4\/","zoom":19,"extra_fields":{"post_excerpt":"Services, troubleshoots, repairs, modifies, preserves, maintains, and overhauls aircraft, aircraft systems, and aircraft components in accordance with policies, procedures, requirements,&hellip;","post_content":"<p>Services, troubleshoots, repairs, modifies, preserves, maintains, and overhauls aircraft, aircraft systems, and aircraft components in accordance with policies, procedures, requirements, and specifications established by the company, applicable government agencies, and aircraft manufactures as contained in approved Maintenance Manuals.<\/p>\n\n<p>Minimum Requirements and Qualification<\/p>\n<p>1. Must hold a valid FAA Airframe and Powerplant license.<\/p>\n<p>2. Must have a valid driver\u2019s license.<\/p>\n<p>3. 3 years of relevant work experience with commercial heavy jets such as B747, B737, A 320, A330 in MRO setting<\/p>\n<p>4. Must have thorough working knowledge of all forms and documents required to support heavy maintenance service, including, but not limited to FAR\u2019s, AD\u2019s, Service Bulletins, and Maintenance Manuals.<\/p>\n<p>5. Must be able to read and interpret technical manuals, instructions, blueprints, and drawings.<\/p>\n<p>6. Must be efficient in the use and application of tools, gauges, instruments, etc. necessary for the accomplishment of duties assigned.<\/p>\n<p>7. Must have an understanding and working knowledge of hazardous material handling and disposal as related to the job assignment.<\/p>\n<p>8. Must be able to obtain an airport SIDA badge (pass criminal background check)<\/p>\n<p>Major Responsibility Areas and Duties<\/p>\n<p>1. Works to written or verbal instructions.<\/p>\n<p>2. Performs all work assigned in accordance with approved maintenance procedures.<\/p>\n<p>3. Records work performed and assumes responsibility for that work as indicated by his\/her signature.<\/p>\n<p>4. Uses blueprints, schematics, technical drawings, and Maintenance Manuals in performance of assigned duties.<\/p>\n<p>5. Must have working knowledge and the ability to service troubleshoot, repair, modify, preserve, maintain, and overhaul aircraft, aircraft system, and aircraft components.<\/p>\n<p>Physical Requirements And Environmental Conditions<\/p>\n<p>1. Must be able to sit, stand, bend, crouch, kneel, and walk for extended periods.<\/p>\n<p>2. Must be able to climb and work from ladders, work stands, and other heights.<\/p>\n<p>3. Must be able to work with one or both hands extended overhead.<\/p>\n<p>4. Must have correctable near and far vision.<\/p>\n<p>5. Must be able to hear at conversational level with hearing aid.<\/p>\n<p>6. Must be able to lift 25 pounds.<\/p>\n<p>7. Must be able to handle and maintain control of small parts and to properly operate hand tools.<\/p>","post_title":"Licensed A&amp;P Mechanic &#8211; Heavy Maintenance","post_link":"https:\/\/turnerstaffing.com\/position\/licensed-ap-mechanic-heavy-maintenance-4\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"","%location_country%":"United States","%location_city%":"Limestone","%location_state_id%":"ME","%location_state_name%":"Maine","%location_city_state%":"Limestone, ME","%education%":"","%department%":"","%description%":"<p>Services, troubleshoots, repairs, modifies, preserves, maintains, and overhauls aircraft, aircraft systems, and aircraft components in accordance with policies, procedures, requirements, and specifications established by the company, applicable government agencies, and aircraft manufactures as contained in approved Maintenance Manuals.<\/p>\n\n<p>Minimum Requirements and Qualification<\/p>\n<p>1. Must hold a valid FAA Airframe and Powerplant license.<\/p>\n<p>2. Must have a valid driver\u2019s license.<\/p>\n<p>3. 3 years of relevant work experience with commercial heavy jets such as B747, B737, A 320, A330 in MRO setting<\/p>\n<p>4. Must have thorough working knowledge of all forms and documents required to support heavy maintenance service, including, but not limited to FAR\u2019s, AD\u2019s, Service Bulletins, and Maintenance Manuals.<\/p>\n<p>5. Must be able to read and interpret technical manuals, instructions, blueprints, and drawings.<\/p>\n<p>6. Must be efficient in the use and application of tools, gauges, instruments, etc. necessary for the accomplishment of duties assigned.<\/p>\n<p>7. Must have an understanding and working knowledge of hazardous material handling and disposal as related to the job assignment.<\/p>\n<p>8. Must be able to obtain an airport SIDA badge (pass criminal background check)<\/p>\n<p>Major Responsibility Areas and Duties<\/p>\n<p>1. Works to written or verbal instructions.<\/p>\n<p>2. Performs all work assigned in accordance with approved maintenance procedures.<\/p>\n<p>3. Records work performed and assumes responsibility for that work as indicated by his\/her signature.<\/p>\n<p>4. Uses blueprints, schematics, technical drawings, and Maintenance Manuals in performance of assigned duties.<\/p>\n<p>5. Must have working knowledge and the ability to service troubleshoot, repair, modify, preserve, maintain, and overhaul aircraft, aircraft system, and aircraft components.<\/p>\n<p>Physical Requirements And Environmental Conditions<\/p>\n<p>1. Must be able to sit, stand, bend, crouch, kneel, and walk for extended periods.<\/p>\n<p>2. Must be able to climb and work from ladders, work stands, and other heights.<\/p>\n<p>3. Must be able to work with one or both hands extended overhead.<\/p>\n<p>4. Must have correctable near and far vision.<\/p>\n<p>5. Must be able to hear at conversational level with hearing aid.<\/p>\n<p>6. Must be able to lift 25 pounds.<\/p>\n<p>7. Must be able to handle and maintain control of small parts and to properly operate hand tools.<\/p>","%category%":"","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/a7325f242f64-licensed-a-p-mechanic-heavy-maintenance","%breezy_id%":"a7325f242f64","%breezy_friendly_id%":"a7325f242f64-licensed-a-p-mechanic-heavy-maintenance","%breezy_created_date%":"2025-08-04T15:47:24.187Z","%breezy_updated_date%":"2025-08-04T15:47:53.839Z","%_wpgmp_location_city%":"Limestone","%_wpgmp_location_state%":"ME","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Limestone, ME, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"46.9086023","%_wpgmp_metabox_longitude%":"-67.825816","%rank_math_internal_links_processed%":"1"}},"id":2674,"infowindow_disable":false},{"source":"post","title":"Licensed A&amp;P Mechanic &#8211; Heavy Maintenance","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Licensed A&amp;P Mechanic &#8211; Heavy Maintenance\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Services, troubleshoots, repairs, modifies, preserves, maintains, and overhauls aircraft, aircraft systems, and aircraft components in accordance with policies, procedures, requirements,&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/licensed-ap-mechanic-heavy-maintenance-2\/\" name=\"Licensed A&amp;P Mechanic &#8211; Heavy Maintenance\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Services, troubleshoots, repairs, modifies, preserves, maintains, and overhauls aircraft, aircraft systems, and aircraft components in accordance with policies, procedures, requirements,&hellip;","address":"Roswell, NM, USA","location":{"lat":"33.3942528","city":"Roswell","state":"NM","country":"United States","lng":"-104.5226958","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/licensed-ap-mechanic-heavy-maintenance-2\/","zoom":19,"extra_fields":{"post_excerpt":"Services, troubleshoots, repairs, modifies, preserves, maintains, and overhauls aircraft, aircraft systems, and aircraft components in accordance with policies, procedures, requirements,&hellip;","post_content":"<p>Services, troubleshoots, repairs, modifies, preserves, maintains, and overhauls aircraft, aircraft systems, and aircraft components in accordance with policies, procedures, requirements, and specifications established by the company, applicable government agencies, and aircraft manufactures as contained in approved Maintenance Manuals.<\/p>\n\n<p>Minimum Requirements and Qualification<\/p>\n<p>1. Must hold a valid FAA Airframe and Powerplant license.<\/p>\n<p>2. Must have a valid driver\u2019s license.<\/p>\n<p>3. 3 years of relevant work experience with commercial heavy jets such as B747, B737, A 320, A330 in MRO setting<\/p>\n<p>4. Must have thorough working knowledge of all forms and documents required to support heavy maintenance service, including, but not limited to FAR\u2019s, AD\u2019s, Service Bulletins, and Maintenance Manuals.<\/p>\n<p>5. Must be able to read and interpret technical manuals, instructions, blueprints, and drawings.<\/p>\n<p>6. Must be efficient in the use and application of tools, gauges, instruments, etc. necessary for the accomplishment of duties assigned.<\/p>\n<p>7. Must have an understanding and working knowledge of hazardous material handling and disposal as related to the job assignment.<\/p>\n<p>8. Must be able to obtain an airport SIDA badge (pass criminal background check)<\/p>\n<p>Major Responsibility Areas and Duties<\/p>\n<p>1. Works to written or verbal instructions.<\/p>\n<p>2. Performs all work assigned in accordance with approved maintenance procedures.<\/p>\n<p>3. Records work performed and assumes responsibility for that work as indicated by his\/her signature.<\/p>\n<p>4. Uses blueprints, schematics, technical drawings, and Maintenance Manuals in performance of assigned duties.<\/p>\n<p>5. Must have working knowledge and the ability to service troubleshoot, repair, modify, preserve, maintain, and overhaul aircraft, aircraft system, and aircraft components.<\/p>\n<p>Physical Requirements And Environmental Conditions<\/p>\n<p>1. Must be able to sit, stand, bend, crouch, kneel, and walk for extended periods.<\/p>\n<p>2. Must be able to climb and work from ladders, work stands, and other heights.<\/p>\n<p>3. Must be able to work with one or both hands extended overhead.<\/p>\n<p>4. Must have correctable near and far vision.<\/p>\n<p>5. Must be able to hear at conversational level with hearing aid.<\/p>\n<p>6. Must be able to lift 25 pounds.<\/p>\n<p>7. Must be able to handle and maintain control of small parts and to properly operate hand tools.<\/p>","post_title":"Licensed A&amp;P Mechanic &#8211; Heavy Maintenance","post_link":"https:\/\/turnerstaffing.com\/position\/licensed-ap-mechanic-heavy-maintenance-2\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"","%location_country%":"United States","%location_city%":"Roswell","%location_state_id%":"NM","%location_state_name%":"New Mexico","%location_city_state%":"Roswell, NM","%education%":"","%department%":"","%description%":"<p>Services, troubleshoots, repairs, modifies, preserves, maintains, and overhauls aircraft, aircraft systems, and aircraft components in accordance with policies, procedures, requirements, and specifications established by the company, applicable government agencies, and aircraft manufactures as contained in approved Maintenance Manuals.<\/p>\n\n<p>Minimum Requirements and Qualification<\/p>\n<p>1. Must hold a valid FAA Airframe and Powerplant license.<\/p>\n<p>2. Must have a valid driver\u2019s license.<\/p>\n<p>3. 3 years of relevant work experience with commercial heavy jets such as B747, B737, A 320, A330 in MRO setting<\/p>\n<p>4. Must have thorough working knowledge of all forms and documents required to support heavy maintenance service, including, but not limited to FAR\u2019s, AD\u2019s, Service Bulletins, and Maintenance Manuals.<\/p>\n<p>5. Must be able to read and interpret technical manuals, instructions, blueprints, and drawings.<\/p>\n<p>6. Must be efficient in the use and application of tools, gauges, instruments, etc. necessary for the accomplishment of duties assigned.<\/p>\n<p>7. Must have an understanding and working knowledge of hazardous material handling and disposal as related to the job assignment.<\/p>\n<p>8. Must be able to obtain an airport SIDA badge (pass criminal background check)<\/p>\n<p>Major Responsibility Areas and Duties<\/p>\n<p>1. Works to written or verbal instructions.<\/p>\n<p>2. Performs all work assigned in accordance with approved maintenance procedures.<\/p>\n<p>3. Records work performed and assumes responsibility for that work as indicated by his\/her signature.<\/p>\n<p>4. Uses blueprints, schematics, technical drawings, and Maintenance Manuals in performance of assigned duties.<\/p>\n<p>5. Must have working knowledge and the ability to service troubleshoot, repair, modify, preserve, maintain, and overhaul aircraft, aircraft system, and aircraft components.<\/p>\n<p>Physical Requirements And Environmental Conditions<\/p>\n<p>1. Must be able to sit, stand, bend, crouch, kneel, and walk for extended periods.<\/p>\n<p>2. Must be able to climb and work from ladders, work stands, and other heights.<\/p>\n<p>3. Must be able to work with one or both hands extended overhead.<\/p>\n<p>4. Must have correctable near and far vision.<\/p>\n<p>5. Must be able to hear at conversational level with hearing aid.<\/p>\n<p>6. Must be able to lift 25 pounds.<\/p>\n<p>7. Must be able to handle and maintain control of small parts and to properly operate hand tools.<\/p>","%category%":"","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/b6750c1b7ab0-licensed-a-p-mechanic-heavy-maintenance","%breezy_id%":"b6750c1b7ab0","%breezy_friendly_id%":"b6750c1b7ab0-licensed-a-p-mechanic-heavy-maintenance","%breezy_created_date%":"2025-08-04T15:44:09.897Z","%breezy_updated_date%":"2025-08-04T15:44:54.958Z","%_wpgmp_location_city%":"Roswell","%_wpgmp_location_state%":"NM","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Roswell, NM, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"33.3942528","%_wpgmp_metabox_longitude%":"-104.5226958","%rank_math_internal_links_processed%":"1"}},"id":2672,"infowindow_disable":false},{"source":"post","title":"Licensed A&amp;P Mechanic &#8211; Heavy Maintenance","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Licensed A&amp;P Mechanic &#8211; Heavy Maintenance\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Services, troubleshoots, repairs, modifies, preserves, maintains, and overhauls aircraft, aircraft systems, and aircraft components in accordance with policies, procedures, requirements,&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/licensed-ap-mechanic-heavy-maintenance-3\/\" name=\"Licensed A&amp;P Mechanic &#8211; Heavy Maintenance\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Services, troubleshoots, repairs, modifies, preserves, maintains, and overhauls aircraft, aircraft systems, and aircraft components in accordance with policies, procedures, requirements,&hellip;","address":"Pensacola, FL, USA","location":{"lat":"30.4076647","city":"Pensacola","state":"FL","country":"United States","lng":"-87.2189746","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/licensed-ap-mechanic-heavy-maintenance-3\/","zoom":19,"extra_fields":{"post_excerpt":"Services, troubleshoots, repairs, modifies, preserves, maintains, and overhauls aircraft, aircraft systems, and aircraft components in accordance with policies, procedures, requirements,&hellip;","post_content":"<p>Services, troubleshoots, repairs, modifies, preserves, maintains, and overhauls aircraft, aircraft systems, and aircraft components in accordance with policies, procedures, requirements, and specifications established by the company, applicable government agencies, and aircraft manufactures as contained in approved Maintenance Manuals.<\/p>\n\n<p>Minimum Requirements and Qualification<\/p>\n<p>1. Must hold a valid FAA Airframe and Powerplant license.<\/p>\n<p>2. Must have a valid driver\u2019s license.<\/p>\n<p>3. 3 years of relevant work experience with commercial heavy jets such as B747, B737, A 320, A330 in MRO setting<\/p>\n<p>4. Must have thorough working knowledge of all forms and documents required to support heavy maintenance service, including, but not limited to FAR\u2019s, AD\u2019s, Service Bulletins, and Maintenance Manuals.<\/p>\n<p>5. Must be able to read and interpret technical manuals, instructions, blueprints, and drawings.<\/p>\n<p>6. Must be efficient in the use and application of tools, gauges, instruments, etc. necessary for the accomplishment of duties assigned.<\/p>\n<p>7. Must have an understanding and working knowledge of hazardous material handling and disposal as related to the job assignment.<\/p>\n<p>8. Must be able to obtain an airport SIDA badge (pass criminal background check)<\/p>\n<p>Major Responsibility Areas and Duties<\/p>\n<p>1. Works to written or verbal instructions.<\/p>\n<p>2. Performs all work assigned in accordance with approved maintenance procedures.<\/p>\n<p>3. Records work performed and assumes responsibility for that work as indicated by his\/her signature.<\/p>\n<p>4. Uses blueprints, schematics, technical drawings, and Maintenance Manuals in performance of assigned duties.<\/p>\n<p>5. Must have working knowledge and the ability to service troubleshoot, repair, modify, preserve, maintain, and overhaul aircraft, aircraft system, and aircraft components.<\/p>\n<p>Physical Requirements And Environmental Conditions<\/p>\n<p>1. Must be able to sit, stand, bend, crouch, kneel, and walk for extended periods.<\/p>\n<p>2. Must be able to climb and work from ladders, work stands, and other heights.<\/p>\n<p>3. Must be able to work with one or both hands extended overhead.<\/p>\n<p>4. Must have correctable near and far vision.<\/p>\n<p>5. Must be able to hear at conversational level with hearing aid.<\/p>\n<p>6. Must be able to lift 25 pounds.<\/p>\n<p>7. Must be able to handle and maintain control of small parts and to properly operate hand tools.<\/p>","post_title":"Licensed A&amp;P Mechanic &#8211; Heavy Maintenance","post_link":"https:\/\/turnerstaffing.com\/position\/licensed-ap-mechanic-heavy-maintenance-3\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"","%location_country%":"United States","%location_city%":"Pensacola","%location_state_id%":"FL","%location_state_name%":"Florida","%location_city_state%":"Pensacola, FL","%education%":"","%department%":"","%description%":"<p>Services, troubleshoots, repairs, modifies, preserves, maintains, and overhauls aircraft, aircraft systems, and aircraft components in accordance with policies, procedures, requirements, and specifications established by the company, applicable government agencies, and aircraft manufactures as contained in approved Maintenance Manuals.<\/p>\n\n<p>Minimum Requirements and Qualification<\/p>\n<p>1. Must hold a valid FAA Airframe and Powerplant license.<\/p>\n<p>2. Must have a valid driver\u2019s license.<\/p>\n<p>3. 3 years of relevant work experience with commercial heavy jets such as B747, B737, A 320, A330 in MRO setting<\/p>\n<p>4. Must have thorough working knowledge of all forms and documents required to support heavy maintenance service, including, but not limited to FAR\u2019s, AD\u2019s, Service Bulletins, and Maintenance Manuals.<\/p>\n<p>5. Must be able to read and interpret technical manuals, instructions, blueprints, and drawings.<\/p>\n<p>6. Must be efficient in the use and application of tools, gauges, instruments, etc. necessary for the accomplishment of duties assigned.<\/p>\n<p>7. Must have an understanding and working knowledge of hazardous material handling and disposal as related to the job assignment.<\/p>\n<p>8. Must be able to obtain an airport SIDA badge (pass criminal background check)<\/p>\n<p>Major Responsibility Areas and Duties<\/p>\n<p>1. Works to written or verbal instructions.<\/p>\n<p>2. Performs all work assigned in accordance with approved maintenance procedures.<\/p>\n<p>3. Records work performed and assumes responsibility for that work as indicated by his\/her signature.<\/p>\n<p>4. Uses blueprints, schematics, technical drawings, and Maintenance Manuals in performance of assigned duties.<\/p>\n<p>5. Must have working knowledge and the ability to service troubleshoot, repair, modify, preserve, maintain, and overhaul aircraft, aircraft system, and aircraft components.<\/p>\n<p>Physical Requirements And Environmental Conditions<\/p>\n<p>1. Must be able to sit, stand, bend, crouch, kneel, and walk for extended periods.<\/p>\n<p>2. Must be able to climb and work from ladders, work stands, and other heights.<\/p>\n<p>3. Must be able to work with one or both hands extended overhead.<\/p>\n<p>4. Must have correctable near and far vision.<\/p>\n<p>5. Must be able to hear at conversational level with hearing aid.<\/p>\n<p>6. Must be able to lift 25 pounds.<\/p>\n<p>7. Must be able to handle and maintain control of small parts and to properly operate hand tools.<\/p>","%category%":"","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/56c056a82c7e-licensed-a-p-mechanic-heavy-maintenance","%breezy_id%":"56c056a82c7e","%breezy_friendly_id%":"56c056a82c7e-licensed-a-p-mechanic-heavy-maintenance","%breezy_created_date%":"2025-08-04T15:45:46.231Z","%breezy_updated_date%":"2025-08-04T15:46:44.351Z","%_wpgmp_location_city%":"Pensacola","%_wpgmp_location_state%":"FL","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Pensacola, FL, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"30.4076647","%_wpgmp_metabox_longitude%":"-87.2189746","%rank_math_internal_links_processed%":"1"}},"id":2673,"infowindow_disable":false},{"source":"post","title":"APG (Unlicensed A&amp;P) Mechanic &#8211; Heavy Maintenance","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    APG (Unlicensed A&amp;P) Mechanic &#8211; Heavy Maintenance\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Services, troubleshoots, repairs, modifies, preserves, maintains, and overhauls aircraft, aircraft systems, and aircraft components in accordance with policies, procedures, requirements,&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/apg-unlicensed-ap-mechanic-heavy-maintenance-3\/\" name=\"APG (Unlicensed A&amp;P) Mechanic &#8211; Heavy Maintenance\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Services, troubleshoots, repairs, modifies, preserves, maintains, and overhauls aircraft, aircraft systems, and aircraft components in accordance with policies, procedures, requirements,&hellip;","address":"Pensacola, FL, USA","location":{"lat":"30.4076647","city":"Pensacola","state":"FL","country":"United States","lng":"-87.2189746","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/apg-unlicensed-ap-mechanic-heavy-maintenance-3\/","zoom":19,"extra_fields":{"post_excerpt":"Services, troubleshoots, repairs, modifies, preserves, maintains, and overhauls aircraft, aircraft systems, and aircraft components in accordance with policies, procedures, requirements,&hellip;","post_content":"<p>Services, troubleshoots, repairs, modifies, preserves, maintains, and overhauls aircraft, aircraft systems, and aircraft components in accordance with policies, procedures, requirements, and specifications established by the company, applicable government agencies, and aircraft manufactures as contained in approved Maintenance Manuals.<\/p>\n\n<p>Minimum Requirements and Qualification<\/p>\n<p>1. Must have a valid driver\u2019s license.<\/p>\n<p>2. 3 years of relevant work experience with commercial heavy jets such as B747, B737, A 320, A330 in MRO setting<\/p>\n<p>3. Must have thorough working knowledge of all forms and documents required to support heavy maintenance service, including, but not limited to FAR\u2019s, AD\u2019s, Service Bulletins, and Maintenance Manuals.<\/p>\n<p>4. Must be able to read and interpret technical manuals, instructions, blueprints, and drawings.<\/p>\n<p>5. Must be efficient in the use and application of tools, gauges, instruments, etc. necessary for the accomplishment of duties assigned.<\/p>\n<p>6. Must have an understanding and working knowledge of hazardous material handling and disposal as related to the job assignment.<\/p>\n<p>7. Must be able to obtain an airport SIDA badge (pass criminal background check)<\/p>\n<p>Major Responsibility Areas and Duties<\/p>\n<p>1. Works to written or verbal instructions.<\/p>\n<p>2. Performs all work assigned in accordance with approved maintenance procedures.<\/p>\n<p>3. Records work performed and assumes responsibility for that work as indicated by his\/her signature.<\/p>\n<p>4. Uses blueprints, schematics, technical drawings, and Maintenance Manuals in performance of assigned duties.<\/p>\n<p>5. Must have working knowledge and the ability to service troubleshoot, repair, modify, preserve, maintain, and overhaul aircraft, aircraft system, and aircraft components.<\/p>\n<p>Physical Requirements and Environmental Conditions<\/p>\n<p>1. Must be able to sit, stand, bend, crouch, kneel, and walk for extended periods.<\/p>\n<p>2. Must be able to climb and work from ladders, work stands, and other heights.<\/p>\n<p>3. Must be able to work with one or both hands extended overhead.<\/p>\n<p>4. Must have correctable near and far vision.<\/p>\n<p>5. Must be able to hear at conversational level with hearing aid.<\/p>\n<p>6. Must be able to lift 25 pounds.<\/p>\n<p>7. Must be able to handle and maintain control of small parts and to properly operate hand tools.<\/p>","post_title":"APG (Unlicensed A&amp;P) Mechanic &#8211; Heavy Maintenance","post_link":"https:\/\/turnerstaffing.com\/position\/apg-unlicensed-ap-mechanic-heavy-maintenance-3\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"","%location_country%":"United States","%location_city%":"Pensacola","%location_state_id%":"FL","%location_state_name%":"Florida","%location_city_state%":"Pensacola, FL","%education%":"","%department%":"","%description%":"<p>Services, troubleshoots, repairs, modifies, preserves, maintains, and overhauls aircraft, aircraft systems, and aircraft components in accordance with policies, procedures, requirements, and specifications established by the company, applicable government agencies, and aircraft manufactures as contained in approved Maintenance Manuals.<\/p>\n\n<p>Minimum Requirements and Qualification<\/p>\n<p>1. Must have a valid driver\u2019s license.<\/p>\n<p>2. 3 years of relevant work experience with commercial heavy jets such as B747, B737, A 320, A330 in MRO setting<\/p>\n<p>3. Must have thorough working knowledge of all forms and documents required to support heavy maintenance service, including, but not limited to FAR\u2019s, AD\u2019s, Service Bulletins, and Maintenance Manuals.<\/p>\n<p>4. Must be able to read and interpret technical manuals, instructions, blueprints, and drawings.<\/p>\n<p>5. Must be efficient in the use and application of tools, gauges, instruments, etc. necessary for the accomplishment of duties assigned.<\/p>\n<p>6. Must have an understanding and working knowledge of hazardous material handling and disposal as related to the job assignment.<\/p>\n<p>7. Must be able to obtain an airport SIDA badge (pass criminal background check)<\/p>\n<p>Major Responsibility Areas and Duties<\/p>\n<p>1. Works to written or verbal instructions.<\/p>\n<p>2. Performs all work assigned in accordance with approved maintenance procedures.<\/p>\n<p>3. Records work performed and assumes responsibility for that work as indicated by his\/her signature.<\/p>\n<p>4. Uses blueprints, schematics, technical drawings, and Maintenance Manuals in performance of assigned duties.<\/p>\n<p>5. Must have working knowledge and the ability to service troubleshoot, repair, modify, preserve, maintain, and overhaul aircraft, aircraft system, and aircraft components.<\/p>\n<p>Physical Requirements and Environmental Conditions<\/p>\n<p>1. Must be able to sit, stand, bend, crouch, kneel, and walk for extended periods.<\/p>\n<p>2. Must be able to climb and work from ladders, work stands, and other heights.<\/p>\n<p>3. Must be able to work with one or both hands extended overhead.<\/p>\n<p>4. Must have correctable near and far vision.<\/p>\n<p>5. Must be able to hear at conversational level with hearing aid.<\/p>\n<p>6. Must be able to lift 25 pounds.<\/p>\n<p>7. Must be able to handle and maintain control of small parts and to properly operate hand tools.<\/p>","%category%":"","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/8c05015b65b6-apg-unlicensed-a-p-mechanic-heavy-maintenance","%breezy_id%":"8c05015b65b6","%breezy_friendly_id%":"8c05015b65b6-apg-unlicensed-a-p-mechanic-heavy-maintenance","%breezy_created_date%":"2025-08-04T15:33:48.703Z","%breezy_updated_date%":"2025-08-04T15:36:19.981Z","%_wpgmp_location_city%":"Pensacola","%_wpgmp_location_state%":"FL","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Pensacola, FL, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"30.4076647","%_wpgmp_metabox_longitude%":"-87.2189746","%rank_math_internal_links_processed%":"1"}},"id":2669,"infowindow_disable":false},{"source":"post","title":"APG (Unlicensed A&amp;P) Mechanic &#8211; Heavy Maintenance","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    APG (Unlicensed A&amp;P) Mechanic &#8211; Heavy Maintenance\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Services, troubleshoots, repairs, modifies, preserves, maintains, and overhauls aircraft, aircraft systems, and aircraft components in accordance with policies, procedures, requirements,&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/apg-unlicensed-ap-mechanic-heavy-maintenance-4\/\" name=\"APG (Unlicensed A&amp;P) Mechanic &#8211; Heavy Maintenance\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Services, troubleshoots, repairs, modifies, preserves, maintains, and overhauls aircraft, aircraft systems, and aircraft components in accordance with policies, procedures, requirements,&hellip;","address":"Limestone, ME, USA","location":{"lat":"46.9086023","city":"Limestone","state":"ME","country":"United States","lng":"-67.825816","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/apg-unlicensed-ap-mechanic-heavy-maintenance-4\/","zoom":19,"extra_fields":{"post_excerpt":"Services, troubleshoots, repairs, modifies, preserves, maintains, and overhauls aircraft, aircraft systems, and aircraft components in accordance with policies, procedures, requirements,&hellip;","post_content":"<p>Services, troubleshoots, repairs, modifies, preserves, maintains, and overhauls aircraft, aircraft systems, and aircraft components in accordance with policies, procedures, requirements, and specifications established by the company, applicable government agencies, and aircraft manufactures as contained in approved Maintenance Manuals.<\/p>\n\n<p>Minimum Requirements and Qualification<\/p>\n<p>1. Must have a valid driver\u2019s license.<\/p>\n<p>2. 3 years of relevant work experience with commercial heavy jets such as B747, B737, A 320, A330 in MRO setting<\/p>\n<p>3. Must have thorough working knowledge of all forms and documents required to support heavy maintenance service, including, but not limited to FAR\u2019s, AD\u2019s, Service Bulletins, and Maintenance Manuals.<\/p>\n<p>4. Must be able to read and interpret technical manuals, instructions, blueprints, and drawings.<\/p>\n<p>5. Must be efficient in the use and application of tools, gauges, instruments, etc. necessary for the accomplishment of duties assigned.<\/p>\n<p>6. Must have an understanding and working knowledge of hazardous material handling and disposal as related to the job assignment.<\/p>\n<p>7. Must be able to obtain an airport SIDA badge (pass criminal background check)<\/p>\n<p>Major Responsibility Areas and Duties<\/p>\n<p>1. Works to written or verbal instructions.<\/p>\n<p>2. Performs all work assigned in accordance with approved maintenance procedures.<\/p>\n<p>3. Records work performed and assumes responsibility for that work as indicated by his\/her signature.<\/p>\n<p>4. Uses blueprints, schematics, technical drawings, and Maintenance Manuals in performance of assigned duties.<\/p>\n<p>5. Must have working knowledge and the ability to service troubleshoot, repair, modify, preserve, maintain, and overhaul aircraft, aircraft system, and aircraft components.<\/p>\n<p>Physical Requirements and Environmental Conditions<\/p>\n<p>1. Must be able to sit, stand, bend, crouch, kneel, and walk for extended periods.<\/p>\n<p>2. Must be able to climb and work from ladders, work stands, and other heights.<\/p>\n<p>3. Must be able to work with one or both hands extended overhead.<\/p>\n<p>4. Must have correctable near and far vision.<\/p>\n<p>5. Must be able to hear at conversational level with hearing aid.<\/p>\n<p>6. Must be able to lift 25 pounds.<\/p>\n<p>7. Must be able to handle and maintain control of small parts and to properly operate hand tools.<\/p>","post_title":"APG (Unlicensed A&amp;P) Mechanic &#8211; Heavy Maintenance","post_link":"https:\/\/turnerstaffing.com\/position\/apg-unlicensed-ap-mechanic-heavy-maintenance-4\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"","%location_country%":"United States","%location_city%":"Limestone","%location_state_id%":"ME","%location_state_name%":"Maine","%location_city_state%":"Limestone, ME","%education%":"","%department%":"","%description%":"<p>Services, troubleshoots, repairs, modifies, preserves, maintains, and overhauls aircraft, aircraft systems, and aircraft components in accordance with policies, procedures, requirements, and specifications established by the company, applicable government agencies, and aircraft manufactures as contained in approved Maintenance Manuals.<\/p>\n\n<p>Minimum Requirements and Qualification<\/p>\n<p>1. Must have a valid driver\u2019s license.<\/p>\n<p>2. 3 years of relevant work experience with commercial heavy jets such as B747, B737, A 320, A330 in MRO setting<\/p>\n<p>3. Must have thorough working knowledge of all forms and documents required to support heavy maintenance service, including, but not limited to FAR\u2019s, AD\u2019s, Service Bulletins, and Maintenance Manuals.<\/p>\n<p>4. Must be able to read and interpret technical manuals, instructions, blueprints, and drawings.<\/p>\n<p>5. Must be efficient in the use and application of tools, gauges, instruments, etc. necessary for the accomplishment of duties assigned.<\/p>\n<p>6. Must have an understanding and working knowledge of hazardous material handling and disposal as related to the job assignment.<\/p>\n<p>7. Must be able to obtain an airport SIDA badge (pass criminal background check)<\/p>\n<p>Major Responsibility Areas and Duties<\/p>\n<p>1. Works to written or verbal instructions.<\/p>\n<p>2. Performs all work assigned in accordance with approved maintenance procedures.<\/p>\n<p>3. Records work performed and assumes responsibility for that work as indicated by his\/her signature.<\/p>\n<p>4. Uses blueprints, schematics, technical drawings, and Maintenance Manuals in performance of assigned duties.<\/p>\n<p>5. Must have working knowledge and the ability to service troubleshoot, repair, modify, preserve, maintain, and overhaul aircraft, aircraft system, and aircraft components.<\/p>\n<p>Physical Requirements and Environmental Conditions<\/p>\n<p>1. Must be able to sit, stand, bend, crouch, kneel, and walk for extended periods.<\/p>\n<p>2. Must be able to climb and work from ladders, work stands, and other heights.<\/p>\n<p>3. Must be able to work with one or both hands extended overhead.<\/p>\n<p>4. Must have correctable near and far vision.<\/p>\n<p>5. Must be able to hear at conversational level with hearing aid.<\/p>\n<p>6. Must be able to lift 25 pounds.<\/p>\n<p>7. Must be able to handle and maintain control of small parts and to properly operate hand tools.<\/p>","%category%":"","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/e676f59dafa7-apg-unlicensed-a-p-mechanic-heavy-maintenance","%breezy_id%":"e676f59dafa7","%breezy_friendly_id%":"e676f59dafa7-apg-unlicensed-a-p-mechanic-heavy-maintenance","%breezy_created_date%":"2025-08-04T15:35:22.184Z","%breezy_updated_date%":"2025-08-04T15:35:49.923Z","%_wpgmp_location_city%":"Limestone","%_wpgmp_location_state%":"ME","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Limestone, ME, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"46.9086023","%_wpgmp_metabox_longitude%":"-67.825816","%rank_math_internal_links_processed%":"1"}},"id":2670,"infowindow_disable":false},{"source":"post","title":"Licensed A&amp;P Mechanic &#8211; Heavy Maintenance","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Licensed A&amp;P Mechanic &#8211; Heavy Maintenance\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Services, troubleshoots, repairs, modifies, preserves, maintains, and overhauls aircraft, aircraft systems, and aircraft components in accordance with policies, procedures, requirements,&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/licensed-ap-mechanic-heavy-maintenance\/\" name=\"Licensed A&amp;P Mechanic &#8211; Heavy Maintenance\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Services, troubleshoots, repairs, modifies, preserves, maintains, and overhauls aircraft, aircraft systems, and aircraft components in accordance with policies, procedures, requirements,&hellip;","address":"Goodyear, AZ, USA","location":{"lat":"33.4353394","city":"Goodyear","state":"AZ","country":"United States","lng":"-112.3576567","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/licensed-ap-mechanic-heavy-maintenance\/","zoom":19,"extra_fields":{"post_excerpt":"Services, troubleshoots, repairs, modifies, preserves, maintains, and overhauls aircraft, aircraft systems, and aircraft components in accordance with policies, procedures, requirements,&hellip;","post_content":"<p>Services, troubleshoots, repairs, modifies, preserves, maintains, and overhauls aircraft, aircraft systems, and aircraft components in accordance with policies, procedures, requirements, and specifications established by the company, applicable government agencies, and aircraft manufactures as contained in approved Maintenance Manuals.<\/p>\n\n<p>Minimum Requirements and Qualification<\/p>\n<p>1. Must hold a valid FAA Airframe and Powerplant license.<\/p>\n<p>2. Must have a valid driver\u2019s license.<\/p>\n<p>3. 3 years of relevant work experience with commercial heavy jets such as B747, B737, A 320, A330 in MRO setting<\/p>\n<p>4. Must have thorough working knowledge of all forms and documents required to support heavy maintenance service, including, but not limited to FAR\u2019s, AD\u2019s, Service Bulletins, and Maintenance Manuals.<\/p>\n<p>5. Must be able to read and interpret technical manuals, instructions, blueprints, and drawings.<\/p>\n<p>6. Must be efficient in the use and application of tools, gauges, instruments, etc. necessary for the accomplishment of duties assigned.<\/p>\n<p>7. Must have an understanding and working knowledge of hazardous material handling and disposal as related to the job assignment.<\/p>\n<p>8. Must be able to obtain an airport SIDA badge (pass criminal background check)<\/p>\n<p>Major Responsibility Areas and Duties<\/p>\n<p>1. Works to written or verbal instructions.<\/p>\n<p>2. Performs all work assigned in accordance with approved maintenance procedures.<\/p>\n<p>3. Records work performed and assumes responsibility for that work as indicated by his\/her signature.<\/p>\n<p>4. Uses blueprints, schematics, technical drawings, and Maintenance Manuals in performance of assigned duties.<\/p>\n<p>5. Must have working knowledge and the ability to service troubleshoot, repair, modify, preserve, maintain, and overhaul aircraft, aircraft system, and aircraft components.<\/p>\n<p>Physical Requirements And Environmental Conditions<\/p>\n<p>1. Must be able to sit, stand, bend, crouch, kneel, and walk for extended periods.<\/p>\n<p>2. Must be able to climb and work from ladders, work stands, and other heights.<\/p>\n<p>3. Must be able to work with one or both hands extended overhead.<\/p>\n<p>4. Must have correctable near and far vision.<\/p>\n<p>5. Must be able to hear at conversational level with hearing aid.<\/p>\n<p>6. Must be able to lift 25 pounds.<\/p>\n<p>7. Must be able to handle and maintain control of small parts and to properly operate hand tools.<\/p>","post_title":"Licensed A&amp;P Mechanic &#8211; Heavy Maintenance","post_link":"https:\/\/turnerstaffing.com\/position\/licensed-ap-mechanic-heavy-maintenance\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"","%location_country%":"United States","%location_city%":"Goodyear","%location_state_id%":"AZ","%location_state_name%":"Arizona","%location_city_state%":"Goodyear, AZ","%education%":"","%department%":"","%description%":"<p>Services, troubleshoots, repairs, modifies, preserves, maintains, and overhauls aircraft, aircraft systems, and aircraft components in accordance with policies, procedures, requirements, and specifications established by the company, applicable government agencies, and aircraft manufactures as contained in approved Maintenance Manuals.<\/p>\n\n<p>Minimum Requirements and Qualification<\/p>\n<p>1. Must hold a valid FAA Airframe and Powerplant license.<\/p>\n<p>2. Must have a valid driver\u2019s license.<\/p>\n<p>3. 3 years of relevant work experience with commercial heavy jets such as B747, B737, A 320, A330 in MRO setting<\/p>\n<p>4. Must have thorough working knowledge of all forms and documents required to support heavy maintenance service, including, but not limited to FAR\u2019s, AD\u2019s, Service Bulletins, and Maintenance Manuals.<\/p>\n<p>5. Must be able to read and interpret technical manuals, instructions, blueprints, and drawings.<\/p>\n<p>6. Must be efficient in the use and application of tools, gauges, instruments, etc. necessary for the accomplishment of duties assigned.<\/p>\n<p>7. Must have an understanding and working knowledge of hazardous material handling and disposal as related to the job assignment.<\/p>\n<p>8. Must be able to obtain an airport SIDA badge (pass criminal background check)<\/p>\n<p>Major Responsibility Areas and Duties<\/p>\n<p>1. Works to written or verbal instructions.<\/p>\n<p>2. Performs all work assigned in accordance with approved maintenance procedures.<\/p>\n<p>3. Records work performed and assumes responsibility for that work as indicated by his\/her signature.<\/p>\n<p>4. Uses blueprints, schematics, technical drawings, and Maintenance Manuals in performance of assigned duties.<\/p>\n<p>5. Must have working knowledge and the ability to service troubleshoot, repair, modify, preserve, maintain, and overhaul aircraft, aircraft system, and aircraft components.<\/p>\n<p>Physical Requirements And Environmental Conditions<\/p>\n<p>1. Must be able to sit, stand, bend, crouch, kneel, and walk for extended periods.<\/p>\n<p>2. Must be able to climb and work from ladders, work stands, and other heights.<\/p>\n<p>3. Must be able to work with one or both hands extended overhead.<\/p>\n<p>4. Must have correctable near and far vision.<\/p>\n<p>5. Must be able to hear at conversational level with hearing aid.<\/p>\n<p>6. Must be able to lift 25 pounds.<\/p>\n<p>7. Must be able to handle and maintain control of small parts and to properly operate hand tools.<\/p>","%category%":"","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/a57c292c0be8-licensed-a-p-mechanic-heavy-maintenance","%breezy_id%":"a57c292c0be8","%breezy_friendly_id%":"a57c292c0be8-licensed-a-p-mechanic-heavy-maintenance","%breezy_created_date%":"2025-08-04T15:39:43.354Z","%breezy_updated_date%":"2025-08-04T15:40:17.137Z","%_wpgmp_location_city%":"Goodyear","%_wpgmp_location_state%":"AZ","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Goodyear, AZ, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"33.4353394","%_wpgmp_metabox_longitude%":"-112.3576567","%rank_math_internal_links_processed%":"1"}},"id":2671,"infowindow_disable":false},{"source":"post","title":"APG (Unlicensed A&amp;P) Mechanic &#8211; Heavy Maintenance","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    APG (Unlicensed A&amp;P) Mechanic &#8211; Heavy Maintenance\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Services, troubleshoots, repairs, modifies, preserves, maintains, and overhauls aircraft, aircraft systems, and aircraft components in accordance with policies, procedures, requirements,&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/apg-unlicensed-ap-mechanic-heavy-maintenance\/\" name=\"APG (Unlicensed A&amp;P) Mechanic &#8211; Heavy Maintenance\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Services, troubleshoots, repairs, modifies, preserves, maintains, and overhauls aircraft, aircraft systems, and aircraft components in accordance with policies, procedures, requirements,&hellip;","address":"Goodyear, AZ, USA","location":{"lat":"33.4353394","city":"Goodyear","state":"AZ","country":"United States","lng":"-112.3576567","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/apg-unlicensed-ap-mechanic-heavy-maintenance\/","zoom":19,"extra_fields":{"post_excerpt":"Services, troubleshoots, repairs, modifies, preserves, maintains, and overhauls aircraft, aircraft systems, and aircraft components in accordance with policies, procedures, requirements,&hellip;","post_content":"<p>Services, troubleshoots, repairs, modifies, preserves, maintains, and overhauls aircraft, aircraft systems, and aircraft components in accordance with policies, procedures, requirements, and specifications established by the company, applicable government agencies, and aircraft manufactures as contained in approved Maintenance Manuals.<\/p>\n\n<p>Minimum Requirements and Qualification<\/p>\n<p>1. Must have a valid driver\u2019s license.<\/p>\n<p>2. 3 years of relevant work experience with commercial heavy jets such as B747, B737, A 320, A330 in MRO setting<\/p>\n<p>3. Must have thorough working knowledge of all forms and documents required to support heavy maintenance service, including, but not limited to FAR\u2019s, AD\u2019s, Service Bulletins, and Maintenance Manuals.<\/p>\n<p>4. Must be able to read and interpret technical manuals, instructions, blueprints, and drawings.<\/p>\n<p>5. Must be efficient in the use and application of tools, gauges, instruments, etc. necessary for the accomplishment of duties assigned.<\/p>\n<p>6. Must have an understanding and working knowledge of hazardous material handling and disposal as related to the job assignment.<\/p>\n<p>7. Must be able to obtain an airport SIDA badge (pass criminal background check)<\/p>\n<p>Major Responsibility Areas and Duties<\/p>\n<p>1. Works to written or verbal instructions.<\/p>\n<p>2. Performs all work assigned in accordance with approved maintenance procedures.<\/p>\n<p>3. Records work performed and assumes responsibility for that work as indicated by his\/her signature.<\/p>\n<p>4. Uses blueprints, schematics, technical drawings, and Maintenance Manuals in performance of assigned duties.<\/p>\n<p>5. Must have working knowledge and the ability to service troubleshoot, repair, modify, preserve, maintain, and overhaul aircraft, aircraft system, and aircraft components.<\/p>\n<p>Physical Requirements and Environmental Conditions<\/p>\n<p>1. Must be able to sit, stand, bend, crouch, kneel, and walk for extended periods.<\/p>\n<p>2. Must be able to climb and work from ladders, work stands, and other heights.<\/p>\n<p>3. Must be able to work with one or both hands extended overhead.<\/p>\n<p>4. Must have correctable near and far vision.<\/p>\n<p>5. Must be able to hear at conversational level with hearing aid.<\/p>\n<p>6. Must be able to lift 25 pounds.<\/p>\n<p>7. Must be able to handle and maintain control of small parts and to properly operate hand tools.<\/p>","post_title":"APG (Unlicensed A&amp;P) Mechanic &#8211; Heavy Maintenance","post_link":"https:\/\/turnerstaffing.com\/position\/apg-unlicensed-ap-mechanic-heavy-maintenance\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"","%location_country%":"United States","%location_city%":"Goodyear","%location_state_id%":"AZ","%location_state_name%":"Arizona","%location_city_state%":"Goodyear, AZ","%education%":"","%department%":"","%description%":"<p>Services, troubleshoots, repairs, modifies, preserves, maintains, and overhauls aircraft, aircraft systems, and aircraft components in accordance with policies, procedures, requirements, and specifications established by the company, applicable government agencies, and aircraft manufactures as contained in approved Maintenance Manuals.<\/p>\n\n<p>Minimum Requirements and Qualification<\/p>\n<p>1. Must have a valid driver\u2019s license.<\/p>\n<p>2. 3 years of relevant work experience with commercial heavy jets such as B747, B737, A 320, A330 in MRO setting<\/p>\n<p>3. Must have thorough working knowledge of all forms and documents required to support heavy maintenance service, including, but not limited to FAR\u2019s, AD\u2019s, Service Bulletins, and Maintenance Manuals.<\/p>\n<p>4. Must be able to read and interpret technical manuals, instructions, blueprints, and drawings.<\/p>\n<p>5. Must be efficient in the use and application of tools, gauges, instruments, etc. necessary for the accomplishment of duties assigned.<\/p>\n<p>6. Must have an understanding and working knowledge of hazardous material handling and disposal as related to the job assignment.<\/p>\n<p>7. Must be able to obtain an airport SIDA badge (pass criminal background check)<\/p>\n<p>Major Responsibility Areas and Duties<\/p>\n<p>1. Works to written or verbal instructions.<\/p>\n<p>2. Performs all work assigned in accordance with approved maintenance procedures.<\/p>\n<p>3. Records work performed and assumes responsibility for that work as indicated by his\/her signature.<\/p>\n<p>4. Uses blueprints, schematics, technical drawings, and Maintenance Manuals in performance of assigned duties.<\/p>\n<p>5. Must have working knowledge and the ability to service troubleshoot, repair, modify, preserve, maintain, and overhaul aircraft, aircraft system, and aircraft components.<\/p>\n<p>Physical Requirements and Environmental Conditions<\/p>\n<p>1. Must be able to sit, stand, bend, crouch, kneel, and walk for extended periods.<\/p>\n<p>2. Must be able to climb and work from ladders, work stands, and other heights.<\/p>\n<p>3. Must be able to work with one or both hands extended overhead.<\/p>\n<p>4. Must have correctable near and far vision.<\/p>\n<p>5. Must be able to hear at conversational level with hearing aid.<\/p>\n<p>6. Must be able to lift 25 pounds.<\/p>\n<p>7. Must be able to handle and maintain control of small parts and to properly operate hand tools.<\/p>","%category%":"","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/57026a5f58f1-apg-unlicensed-a-p-mechanic-heavy-maintenance","%breezy_id%":"57026a5f58f1","%breezy_friendly_id%":"57026a5f58f1-apg-unlicensed-a-p-mechanic-heavy-maintenance","%breezy_created_date%":"2025-08-04T15:30:39.207Z","%breezy_updated_date%":"2025-08-04T15:31:32.199Z","%_wpgmp_location_city%":"Goodyear","%_wpgmp_location_state%":"AZ","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Goodyear, AZ, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"33.4353394","%_wpgmp_metabox_longitude%":"-112.3576567","%rank_math_internal_links_processed%":"1"}},"id":2667,"infowindow_disable":false},{"source":"post","title":"APG (Unlicensed A&amp;P) Mechanic &#8211; Heavy Maintenance","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    APG (Unlicensed A&amp;P) Mechanic &#8211; Heavy Maintenance\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Services, troubleshoots, repairs, modifies, preserves, maintains, and overhauls aircraft, aircraft systems, and aircraft components in accordance with policies, procedures, requirements,&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/apg-unlicensed-ap-mechanic-heavy-maintenance-2\/\" name=\"APG (Unlicensed A&amp;P) Mechanic &#8211; Heavy Maintenance\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Services, troubleshoots, repairs, modifies, preserves, maintains, and overhauls aircraft, aircraft systems, and aircraft components in accordance with policies, procedures, requirements,&hellip;","address":"Roswell, NM, USA","location":{"lat":"33.3942528","city":"Roswell","state":"NM","country":"United States","lng":"-104.5226958","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/apg-unlicensed-ap-mechanic-heavy-maintenance-2\/","zoom":19,"extra_fields":{"post_excerpt":"Services, troubleshoots, repairs, modifies, preserves, maintains, and overhauls aircraft, aircraft systems, and aircraft components in accordance with policies, procedures, requirements,&hellip;","post_content":"<p>Services, troubleshoots, repairs, modifies, preserves, maintains, and overhauls aircraft, aircraft systems, and aircraft components in accordance with policies, procedures, requirements, and specifications established by the company, applicable government agencies, and aircraft manufactures as contained in approved Maintenance Manuals.<\/p>\n\n<p>Minimum Requirements and Qualification<\/p>\n<p>1. Must have a valid driver\u2019s license.<\/p>\n<p>2. 3 years of relevant work experience with commercial heavy jets such as B747, B737, A 320, A330 in MRO setting<\/p>\n<p>3. Must have thorough working knowledge of all forms and documents required to support heavy maintenance service, including, but not limited to FAR\u2019s, AD\u2019s, Service Bulletins, and Maintenance Manuals.<\/p>\n<p>4. Must be able to read and interpret technical manuals, instructions, blueprints, and drawings.<\/p>\n<p>5. Must be efficient in the use and application of tools, gauges, instruments, etc. necessary for the accomplishment of duties assigned.<\/p>\n<p>6. Must have an understanding and working knowledge of hazardous material handling and disposal as related to the job assignment.<\/p>\n<p>7. Must be able to obtain an airport SIDA badge (pass criminal background check)<\/p>\n<p>Major Responsibility Areas and Duties<\/p>\n<p>1. Works to written or verbal instructions.<\/p>\n<p>2. Performs all work assigned in accordance with approved maintenance procedures.<\/p>\n<p>3. Records work performed and assumes responsibility for that work as indicated by his\/her signature.<\/p>\n<p>4. Uses blueprints, schematics, technical drawings, and Maintenance Manuals in performance of assigned duties.<\/p>\n<p>5. Must have working knowledge and the ability to service troubleshoot, repair, modify, preserve, maintain, and overhaul aircraft, aircraft system, and aircraft components.<\/p>\n<p>Physical Requirements and Environmental Conditions<\/p>\n<p>1. Must be able to sit, stand, bend, crouch, kneel, and walk for extended periods.<\/p>\n<p>2. Must be able to climb and work from ladders, work stands, and other heights.<\/p>\n<p>3. Must be able to work with one or both hands extended overhead.<\/p>\n<p>4. Must have correctable near and far vision.<\/p>\n<p>5. Must be able to hear at conversational level with hearing aid.<\/p>\n<p>6. Must be able to lift 25 pounds.<\/p>\n<p>7. Must be able to handle and maintain control of small parts and to properly operate hand tools.<\/p>","post_title":"APG (Unlicensed A&amp;P) Mechanic &#8211; Heavy Maintenance","post_link":"https:\/\/turnerstaffing.com\/position\/apg-unlicensed-ap-mechanic-heavy-maintenance-2\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"","%location_country%":"United States","%location_city%":"Roswell","%location_state_id%":"NM","%location_state_name%":"New Mexico","%location_city_state%":"Roswell, NM","%education%":"","%department%":"","%description%":"<p>Services, troubleshoots, repairs, modifies, preserves, maintains, and overhauls aircraft, aircraft systems, and aircraft components in accordance with policies, procedures, requirements, and specifications established by the company, applicable government agencies, and aircraft manufactures as contained in approved Maintenance Manuals.<\/p>\n\n<p>Minimum Requirements and Qualification<\/p>\n<p>1. Must have a valid driver\u2019s license.<\/p>\n<p>2. 3 years of relevant work experience with commercial heavy jets such as B747, B737, A 320, A330 in MRO setting<\/p>\n<p>3. Must have thorough working knowledge of all forms and documents required to support heavy maintenance service, including, but not limited to FAR\u2019s, AD\u2019s, Service Bulletins, and Maintenance Manuals.<\/p>\n<p>4. Must be able to read and interpret technical manuals, instructions, blueprints, and drawings.<\/p>\n<p>5. Must be efficient in the use and application of tools, gauges, instruments, etc. necessary for the accomplishment of duties assigned.<\/p>\n<p>6. Must have an understanding and working knowledge of hazardous material handling and disposal as related to the job assignment.<\/p>\n<p>7. Must be able to obtain an airport SIDA badge (pass criminal background check)<\/p>\n<p>Major Responsibility Areas and Duties<\/p>\n<p>1. Works to written or verbal instructions.<\/p>\n<p>2. Performs all work assigned in accordance with approved maintenance procedures.<\/p>\n<p>3. Records work performed and assumes responsibility for that work as indicated by his\/her signature.<\/p>\n<p>4. Uses blueprints, schematics, technical drawings, and Maintenance Manuals in performance of assigned duties.<\/p>\n<p>5. Must have working knowledge and the ability to service troubleshoot, repair, modify, preserve, maintain, and overhaul aircraft, aircraft system, and aircraft components.<\/p>\n<p>Physical Requirements and Environmental Conditions<\/p>\n<p>1. Must be able to sit, stand, bend, crouch, kneel, and walk for extended periods.<\/p>\n<p>2. Must be able to climb and work from ladders, work stands, and other heights.<\/p>\n<p>3. Must be able to work with one or both hands extended overhead.<\/p>\n<p>4. Must have correctable near and far vision.<\/p>\n<p>5. Must be able to hear at conversational level with hearing aid.<\/p>\n<p>6. Must be able to lift 25 pounds.<\/p>\n<p>7. Must be able to handle and maintain control of small parts and to properly operate hand tools.<\/p>","%category%":"","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/c5b5508c064c-apg-unlicensed-a-p-mechanic-heavy-maintenance","%breezy_id%":"c5b5508c064c","%breezy_friendly_id%":"c5b5508c064c-apg-unlicensed-a-p-mechanic-heavy-maintenance","%breezy_created_date%":"2025-08-04T15:32:24.104Z","%breezy_updated_date%":"2025-08-04T15:32:57.082Z","%_wpgmp_location_city%":"Roswell","%_wpgmp_location_state%":"NM","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Roswell, NM, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"33.3942528","%_wpgmp_metabox_longitude%":"-104.5226958","%rank_math_internal_links_processed%":"1"}},"id":2668,"infowindow_disable":false},{"source":"post","title":"Sheet Metal\/Structures Mechanic &#8211; Heavy Maintenance","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Sheet Metal\/Structures Mechanic &#8211; Heavy Maintenance\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Complete large-scale structural repairs, intricate skin work, and critical disassembly tasks on commercial aircraft as part of broader work servicing,&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/sheet-metal-structures-mechanic-heavy-maintenance-2\/\" name=\"Sheet Metal\/Structures Mechanic &#8211; Heavy Maintenance\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Complete large-scale structural repairs, intricate skin work, and critical disassembly tasks on commercial aircraft as part of broader work servicing,&hellip;","address":"Goodyear, AZ, USA","location":{"lat":"33.4353394","city":"Goodyear","state":"AZ","country":"United States","lng":"-112.3576567","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/sheet-metal-structures-mechanic-heavy-maintenance-2\/","zoom":19,"extra_fields":{"post_excerpt":"Complete large-scale structural repairs, intricate skin work, and critical disassembly tasks on commercial aircraft as part of broader work servicing,&hellip;","post_content":"<p>Complete large-scale structural repairs, intricate skin work, and critical disassembly tasks on commercial aircraft as part of broader work servicing, troubleshooting, repairing, modifying, and maintaining commercial aircraft. Complete work in accordance with policies, procedures, requirements, and specifications established by the company, applicable government agencies, and aircraft manufactures as contained in approved Maintenance Manuals.<\/p>\n\n<p>Minimum Requirements and Qualification<\/p>\n<p>1. Must have a valid driver\u2019s license.<\/p>\n<p>2. 3 years of relevant work experience with commercial heavy jets such as B747, B737, A 320, A330 in MRO setting<\/p>\n<p>3. Must have thorough working knowledge of all forms and documents required to support heavy maintenance service, including, but not limited to FAR\u2019s, AD\u2019s, Service Bulletins, and Maintenance Manuals.<\/p>\n<p>4. Proficient detail blueprint reading, ability to read, interpret and work from service bulletins, engineering work orders, major S.R.M. structural repairs, ability to layout work using bend radius, set back and bend allowance charts, utilization of shop math, knowledge of ATA codes, knowledge of all applicable F.A.R.\u2019s and company policies and procedures including job clocking procedures, routine\/ non-routine cards, and work sign-off\/ sell-off procedures<\/p>\n<p>5. Ability to complete large skin repairs requiring doublers \/ triplers containing complex contours<\/p>\n<p>6. Must be efficient in the use and application of tools, gauges, instruments, etc. necessary for the accomplishment of duties assigned.<\/p>\n<p>7. Must have an understanding and working knowledge of hazardous material handling and disposal as related to the job assignment.<\/p>\n<p>8. Must be able to obtain an airport SIDA badge (pass criminal background check)<\/p>\n<p>Major Responsibility Areas and Duties<\/p>\n<p>1. Works to written or verbal instructions.<\/p>\n<p>2. Performs all work assigned in accordance with approved maintenance procedures.<\/p>\n<p>3. Records work performed and assumes responsibility for that work as indicated by his\/her signature.<\/p>\n<p>4. Uses blueprints, schematics, technical drawings, and Maintenance Manuals in performance of assigned duties.<\/p>\n<p>5. Must have working knowledge and the ability to service troubleshoot, repair, modify, preserve, maintain, and overhaul aircraft, aircraft system, and aircraft components.<\/p>\n<p>Physical Requirements And Environmental Conditions<\/p>\n<p>1. Must be able to sit, stand, bend, crouch, kneel, and walk for extended periods.<\/p>\n<p>2. Must be able to climb and work from ladders, work stands, and other heights.<\/p>\n<p>3. Must be able to work with one or both hands extended overhead.<\/p>\n<p>4. Must have correctable near and far vision.<\/p>\n<p>5. Must be able to hear at conversational level with hearing aid.<\/p>\n<p>6. Must be able to lift 50 pounds.<\/p>\n<p>7. Must be able to handle and maintain control of small parts and to properly operate hand tools.<\/p>","post_title":"Sheet Metal\/Structures Mechanic &#8211; Heavy Maintenance","post_link":"https:\/\/turnerstaffing.com\/position\/sheet-metal-structures-mechanic-heavy-maintenance-2\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"","%location_country%":"United States","%location_city%":"Goodyear","%location_state_id%":"AZ","%location_state_name%":"Arizona","%location_city_state%":"Goodyear, AZ","%education%":"","%department%":"","%description%":"<p>Complete large-scale structural repairs, intricate skin work, and critical disassembly tasks on commercial aircraft as part of broader work servicing, troubleshooting, repairing, modifying, and maintaining commercial aircraft. Complete work in accordance with policies, procedures, requirements, and specifications established by the company, applicable government agencies, and aircraft manufactures as contained in approved Maintenance Manuals.<\/p>\n\n<p>Minimum Requirements and Qualification<\/p>\n<p>1. Must have a valid driver\u2019s license.<\/p>\n<p>2. 3 years of relevant work experience with commercial heavy jets such as B747, B737, A 320, A330 in MRO setting<\/p>\n<p>3. Must have thorough working knowledge of all forms and documents required to support heavy maintenance service, including, but not limited to FAR\u2019s, AD\u2019s, Service Bulletins, and Maintenance Manuals.<\/p>\n<p>4. Proficient detail blueprint reading, ability to read, interpret and work from service bulletins, engineering work orders, major S.R.M. structural repairs, ability to layout work using bend radius, set back and bend allowance charts, utilization of shop math, knowledge of ATA codes, knowledge of all applicable F.A.R.\u2019s and company policies and procedures including job clocking procedures, routine\/ non-routine cards, and work sign-off\/ sell-off procedures<\/p>\n<p>5. Ability to complete large skin repairs requiring doublers \/ triplers containing complex contours<\/p>\n<p>6. Must be efficient in the use and application of tools, gauges, instruments, etc. necessary for the accomplishment of duties assigned.<\/p>\n<p>7. Must have an understanding and working knowledge of hazardous material handling and disposal as related to the job assignment.<\/p>\n<p>8. Must be able to obtain an airport SIDA badge (pass criminal background check)<\/p>\n<p>Major Responsibility Areas and Duties<\/p>\n<p>1. Works to written or verbal instructions.<\/p>\n<p>2. Performs all work assigned in accordance with approved maintenance procedures.<\/p>\n<p>3. Records work performed and assumes responsibility for that work as indicated by his\/her signature.<\/p>\n<p>4. Uses blueprints, schematics, technical drawings, and Maintenance Manuals in performance of assigned duties.<\/p>\n<p>5. Must have working knowledge and the ability to service troubleshoot, repair, modify, preserve, maintain, and overhaul aircraft, aircraft system, and aircraft components.<\/p>\n<p>Physical Requirements And Environmental Conditions<\/p>\n<p>1. Must be able to sit, stand, bend, crouch, kneel, and walk for extended periods.<\/p>\n<p>2. Must be able to climb and work from ladders, work stands, and other heights.<\/p>\n<p>3. Must be able to work with one or both hands extended overhead.<\/p>\n<p>4. Must have correctable near and far vision.<\/p>\n<p>5. Must be able to hear at conversational level with hearing aid.<\/p>\n<p>6. Must be able to lift 50 pounds.<\/p>\n<p>7. Must be able to handle and maintain control of small parts and to properly operate hand tools.<\/p>","%category%":"","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/14908e0dd161-sheet-metal-structures-mechanic-heavy-maintenance","%breezy_id%":"14908e0dd161","%breezy_friendly_id%":"14908e0dd161-sheet-metal-structures-mechanic-heavy-maintenance","%breezy_created_date%":"2025-08-04T15:22:53.295Z","%breezy_updated_date%":"2025-08-04T15:23:37.590Z","%_wpgmp_location_city%":"Goodyear","%_wpgmp_location_state%":"AZ","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Goodyear, AZ, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"33.4353394","%_wpgmp_metabox_longitude%":"-112.3576567","%rank_math_internal_links_processed%":"1"}},"id":2664,"infowindow_disable":false},{"source":"post","title":"Sheet Metal\/Structures Mechanic &#8211; Heavy Maintenance","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Sheet Metal\/Structures Mechanic &#8211; Heavy Maintenance\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Complete large-scale structural repairs, intricate skin work, and critical disassembly tasks on commercial aircraft as part of broader work servicing,&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/sheet-metal-structures-mechanic-heavy-maintenance-3\/\" name=\"Sheet Metal\/Structures Mechanic &#8211; Heavy Maintenance\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Complete large-scale structural repairs, intricate skin work, and critical disassembly tasks on commercial aircraft as part of broader work servicing,&hellip;","address":"Roswell, NM, USA","location":{"lat":"33.3942528","city":"Roswell","state":"NM","country":"United States","lng":"-104.5226958","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/sheet-metal-structures-mechanic-heavy-maintenance-3\/","zoom":19,"extra_fields":{"post_excerpt":"Complete large-scale structural repairs, intricate skin work, and critical disassembly tasks on commercial aircraft as part of broader work servicing,&hellip;","post_content":"<p>Complete large-scale structural repairs, intricate skin work, and critical disassembly tasks on commercial aircraft as part of broader work servicing, troubleshooting, repairing, modifying, and maintaining commercial aircraft. Complete work in accordance with policies, procedures, requirements, and specifications established by the company, applicable government agencies, and aircraft manufactures as contained in approved Maintenance Manuals.<\/p>\n\n<p>Minimum Requirements and Qualification<\/p>\n<p>1. Must have a valid driver\u2019s license.<\/p>\n<p>2. 3 years of relevant work experience with commercial heavy jets such as B747, B737, A 320, A330 in MRO setting<\/p>\n<p>3. Must have thorough working knowledge of all forms and documents required to support heavy maintenance service, including, but not limited to FAR\u2019s, AD\u2019s, Service Bulletins, and Maintenance Manuals.<\/p>\n<p>4. Proficient detail blueprint reading, ability to read, interpret and work from service bulletins, engineering work orders, major S.R.M. structural repairs, ability to layout work using bend radius, set back and bend allowance charts, utilization of shop math, knowledge of ATA codes, knowledge of all applicable F.A.R.\u2019s and company policies and procedures including job clocking procedures, routine\/ non-routine cards, and work sign-off\/ sell-off procedures<\/p>\n<p>5. Ability to complete large skin repairs requiring doublers \/ triplers containing complex contours<\/p>\n<p>6. Must be efficient in the use and application of tools, gauges, instruments, etc. necessary for the accomplishment of duties assigned.<\/p>\n<p>7. Must have an understanding and working knowledge of hazardous material handling and disposal as related to the job assignment.<\/p>\n<p>8. Must be able to obtain an airport SIDA badge (pass criminal background check)<\/p>\n<p>Major Responsibility Areas and Duties<\/p>\n<p>1. Works to written or verbal instructions.<\/p>\n<p>2. Performs all work assigned in accordance with approved maintenance procedures.<\/p>\n<p>3. Records work performed and assumes responsibility for that work as indicated by his\/her signature.<\/p>\n<p>4. Uses blueprints, schematics, technical drawings, and Maintenance Manuals in performance of assigned duties.<\/p>\n<p>5. Must have working knowledge and the ability to service troubleshoot, repair, modify, preserve, maintain, and overhaul aircraft, aircraft system, and aircraft components.<\/p>\n<p>Physical Requirements And Environmental Conditions<\/p>\n<p>1. Must be able to sit, stand, bend, crouch, kneel, and walk for extended periods.<\/p>\n<p>2. Must be able to climb and work from ladders, work stands, and other heights.<\/p>\n<p>3. Must be able to work with one or both hands extended overhead.<\/p>\n<p>4. Must have correctable near and far vision.<\/p>\n<p>5. Must be able to hear at conversational level with hearing aid.<\/p>\n<p>6. Must be able to lift 50 pounds.<\/p>\n<p>7. Must be able to handle and maintain control of small parts and to properly operate hand tools.<\/p>","post_title":"Sheet Metal\/Structures Mechanic &#8211; Heavy Maintenance","post_link":"https:\/\/turnerstaffing.com\/position\/sheet-metal-structures-mechanic-heavy-maintenance-3\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"","%location_country%":"United States","%location_city%":"Roswell","%location_state_id%":"NM","%location_state_name%":"New Mexico","%location_city_state%":"Roswell, NM","%education%":"","%department%":"","%description%":"<p>Complete large-scale structural repairs, intricate skin work, and critical disassembly tasks on commercial aircraft as part of broader work servicing, troubleshooting, repairing, modifying, and maintaining commercial aircraft. Complete work in accordance with policies, procedures, requirements, and specifications established by the company, applicable government agencies, and aircraft manufactures as contained in approved Maintenance Manuals.<\/p>\n\n<p>Minimum Requirements and Qualification<\/p>\n<p>1. Must have a valid driver\u2019s license.<\/p>\n<p>2. 3 years of relevant work experience with commercial heavy jets such as B747, B737, A 320, A330 in MRO setting<\/p>\n<p>3. Must have thorough working knowledge of all forms and documents required to support heavy maintenance service, including, but not limited to FAR\u2019s, AD\u2019s, Service Bulletins, and Maintenance Manuals.<\/p>\n<p>4. Proficient detail blueprint reading, ability to read, interpret and work from service bulletins, engineering work orders, major S.R.M. structural repairs, ability to layout work using bend radius, set back and bend allowance charts, utilization of shop math, knowledge of ATA codes, knowledge of all applicable F.A.R.\u2019s and company policies and procedures including job clocking procedures, routine\/ non-routine cards, and work sign-off\/ sell-off procedures<\/p>\n<p>5. Ability to complete large skin repairs requiring doublers \/ triplers containing complex contours<\/p>\n<p>6. Must be efficient in the use and application of tools, gauges, instruments, etc. necessary for the accomplishment of duties assigned.<\/p>\n<p>7. Must have an understanding and working knowledge of hazardous material handling and disposal as related to the job assignment.<\/p>\n<p>8. Must be able to obtain an airport SIDA badge (pass criminal background check)<\/p>\n<p>Major Responsibility Areas and Duties<\/p>\n<p>1. Works to written or verbal instructions.<\/p>\n<p>2. Performs all work assigned in accordance with approved maintenance procedures.<\/p>\n<p>3. Records work performed and assumes responsibility for that work as indicated by his\/her signature.<\/p>\n<p>4. Uses blueprints, schematics, technical drawings, and Maintenance Manuals in performance of assigned duties.<\/p>\n<p>5. Must have working knowledge and the ability to service troubleshoot, repair, modify, preserve, maintain, and overhaul aircraft, aircraft system, and aircraft components.<\/p>\n<p>Physical Requirements And Environmental Conditions<\/p>\n<p>1. Must be able to sit, stand, bend, crouch, kneel, and walk for extended periods.<\/p>\n<p>2. Must be able to climb and work from ladders, work stands, and other heights.<\/p>\n<p>3. Must be able to work with one or both hands extended overhead.<\/p>\n<p>4. Must have correctable near and far vision.<\/p>\n<p>5. Must be able to hear at conversational level with hearing aid.<\/p>\n<p>6. Must be able to lift 50 pounds.<\/p>\n<p>7. Must be able to handle and maintain control of small parts and to properly operate hand tools.<\/p>","%category%":"","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/7f2c84c2c129-sheet-metal-structures-mechanic-heavy-maintenance","%breezy_id%":"7f2c84c2c129","%breezy_friendly_id%":"7f2c84c2c129-sheet-metal-structures-mechanic-heavy-maintenance","%breezy_created_date%":"2025-08-04T15:24:23.294Z","%breezy_updated_date%":"2025-08-04T15:24:53.429Z","%_wpgmp_location_city%":"Roswell","%_wpgmp_location_state%":"NM","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Roswell, NM, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"33.3942528","%_wpgmp_metabox_longitude%":"-104.5226958","%rank_math_internal_links_processed%":"1"}},"id":2665,"infowindow_disable":false},{"source":"post","title":"Sheet Metal\/Structures Mechanic &#8211; Heavy Maintenance","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Sheet Metal\/Structures Mechanic &#8211; Heavy Maintenance\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Complete large-scale structural repairs, intricate skin work, and critical disassembly tasks on commercial aircraft as part of broader work servicing,&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/sheet-metal-structures-mechanic-heavy-maintenance-4\/\" name=\"Sheet Metal\/Structures Mechanic &#8211; Heavy Maintenance\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Complete large-scale structural repairs, intricate skin work, and critical disassembly tasks on commercial aircraft as part of broader work servicing,&hellip;","address":"Limestone, ME, USA","location":{"lat":"46.9086023","city":"Limestone","state":"ME","country":"United States","lng":"-67.825816","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/sheet-metal-structures-mechanic-heavy-maintenance-4\/","zoom":19,"extra_fields":{"post_excerpt":"Complete large-scale structural repairs, intricate skin work, and critical disassembly tasks on commercial aircraft as part of broader work servicing,&hellip;","post_content":"<p>Complete large-scale structural repairs, intricate skin work, and critical disassembly tasks on commercial aircraft as part of broader work servicing, troubleshooting, repairing, modifying, and maintaining commercial aircraft. Complete work in accordance with policies, procedures, requirements, and specifications established by the company, applicable government agencies, and aircraft manufactures as contained in approved Maintenance Manuals.<\/p>\n\n<p>Minimum Requirements and Qualification<\/p>\n<p>1. Must have a valid driver\u2019s license.<\/p>\n<p>2. 3 years of relevant work experience with commercial heavy jets such as B747, B737, A 320, A330 in MRO setting<\/p>\n<p>3. Must have thorough working knowledge of all forms and documents required to support heavy maintenance service, including, but not limited to FAR\u2019s, AD\u2019s, Service Bulletins, and Maintenance Manuals.<\/p>\n<p>4. Proficient detail blueprint reading, ability to read, interpret and work from service bulletins, engineering work orders, major S.R.M. structural repairs, ability to layout work using bend radius, set back and bend allowance charts, utilization of shop math, knowledge of ATA codes, knowledge of all applicable F.A.R.\u2019s and company policies and procedures including job clocking procedures, routine\/ non-routine cards, and work sign-off\/ sell-off procedures<\/p>\n<p>5. Ability to complete large skin repairs requiring doublers \/ triplers containing complex contours<\/p>\n<p>6. Must be efficient in the use and application of tools, gauges, instruments, etc. necessary for the accomplishment of duties assigned.<\/p>\n<p>7. Must have an understanding and working knowledge of hazardous material handling and disposal as related to the job assignment.<\/p>\n<p>8. Must be able to obtain an airport SIDA badge (pass criminal background check)<\/p>\n<p>Major Responsibility Areas and Duties<\/p>\n<p>1. Works to written or verbal instructions.<\/p>\n<p>2. Performs all work assigned in accordance with approved maintenance procedures.<\/p>\n<p>3. Records work performed and assumes responsibility for that work as indicated by his\/her signature.<\/p>\n<p>4. Uses blueprints, schematics, technical drawings, and Maintenance Manuals in performance of assigned duties.<\/p>\n<p>5. Must have working knowledge and the ability to service troubleshoot, repair, modify, preserve, maintain, and overhaul aircraft, aircraft system, and aircraft components.<\/p>\n<p>Physical Requirements And Environmental Conditions<\/p>\n<p>1. Must be able to sit, stand, bend, crouch, kneel, and walk for extended periods.<\/p>\n<p>2. Must be able to climb and work from ladders, work stands, and other heights.<\/p>\n<p>3. Must be able to work with one or both hands extended overhead.<\/p>\n<p>4. Must have correctable near and far vision.<\/p>\n<p>5. Must be able to hear at conversational level with hearing aid.<\/p>\n<p>6. Must be able to lift 50 pounds.<\/p>\n<p>7. Must be able to handle and maintain control of small parts and to properly operate hand tools.<\/p>","post_title":"Sheet Metal\/Structures Mechanic &#8211; Heavy Maintenance","post_link":"https:\/\/turnerstaffing.com\/position\/sheet-metal-structures-mechanic-heavy-maintenance-4\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"","%location_country%":"United States","%location_city%":"Limestone","%location_state_id%":"ME","%location_state_name%":"Maine","%location_city_state%":"Limestone, ME","%education%":"","%department%":"","%description%":"<p>Complete large-scale structural repairs, intricate skin work, and critical disassembly tasks on commercial aircraft as part of broader work servicing, troubleshooting, repairing, modifying, and maintaining commercial aircraft. Complete work in accordance with policies, procedures, requirements, and specifications established by the company, applicable government agencies, and aircraft manufactures as contained in approved Maintenance Manuals.<\/p>\n\n<p>Minimum Requirements and Qualification<\/p>\n<p>1. Must have a valid driver\u2019s license.<\/p>\n<p>2. 3 years of relevant work experience with commercial heavy jets such as B747, B737, A 320, A330 in MRO setting<\/p>\n<p>3. Must have thorough working knowledge of all forms and documents required to support heavy maintenance service, including, but not limited to FAR\u2019s, AD\u2019s, Service Bulletins, and Maintenance Manuals.<\/p>\n<p>4. Proficient detail blueprint reading, ability to read, interpret and work from service bulletins, engineering work orders, major S.R.M. structural repairs, ability to layout work using bend radius, set back and bend allowance charts, utilization of shop math, knowledge of ATA codes, knowledge of all applicable F.A.R.\u2019s and company policies and procedures including job clocking procedures, routine\/ non-routine cards, and work sign-off\/ sell-off procedures<\/p>\n<p>5. Ability to complete large skin repairs requiring doublers \/ triplers containing complex contours<\/p>\n<p>6. Must be efficient in the use and application of tools, gauges, instruments, etc. necessary for the accomplishment of duties assigned.<\/p>\n<p>7. Must have an understanding and working knowledge of hazardous material handling and disposal as related to the job assignment.<\/p>\n<p>8. Must be able to obtain an airport SIDA badge (pass criminal background check)<\/p>\n<p>Major Responsibility Areas and Duties<\/p>\n<p>1. Works to written or verbal instructions.<\/p>\n<p>2. Performs all work assigned in accordance with approved maintenance procedures.<\/p>\n<p>3. Records work performed and assumes responsibility for that work as indicated by his\/her signature.<\/p>\n<p>4. Uses blueprints, schematics, technical drawings, and Maintenance Manuals in performance of assigned duties.<\/p>\n<p>5. Must have working knowledge and the ability to service troubleshoot, repair, modify, preserve, maintain, and overhaul aircraft, aircraft system, and aircraft components.<\/p>\n<p>Physical Requirements And Environmental Conditions<\/p>\n<p>1. Must be able to sit, stand, bend, crouch, kneel, and walk for extended periods.<\/p>\n<p>2. Must be able to climb and work from ladders, work stands, and other heights.<\/p>\n<p>3. Must be able to work with one or both hands extended overhead.<\/p>\n<p>4. Must have correctable near and far vision.<\/p>\n<p>5. Must be able to hear at conversational level with hearing aid.<\/p>\n<p>6. Must be able to lift 50 pounds.<\/p>\n<p>7. Must be able to handle and maintain control of small parts and to properly operate hand tools.<\/p>","%category%":"","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/46d346b7aa98-sheet-metal-structures-mechanic-heavy-maintenance","%breezy_id%":"46d346b7aa98","%breezy_friendly_id%":"46d346b7aa98-sheet-metal-structures-mechanic-heavy-maintenance","%breezy_created_date%":"2025-08-04T15:25:49.675Z","%breezy_updated_date%":"2025-08-04T15:26:28.283Z","%_wpgmp_location_city%":"Limestone","%_wpgmp_location_state%":"ME","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Limestone, ME, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"46.9086023","%_wpgmp_metabox_longitude%":"-67.825816","%rank_math_internal_links_processed%":"1"}},"id":2666,"infowindow_disable":false},{"source":"post","title":"Sheet Metal \/ Structures Mechanic &#8211; Heavy Maintenance","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Sheet Metal \/ Structures Mechanic &#8211; Heavy Maintenance\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Complete large-scale structural repairs, intricate skin work, and critical disassembly tasks on commercial aircraft as part of broader work servicing,&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/sheet-metal-structures-mechanic-heavy-maintenance\/\" name=\"Sheet Metal \/ Structures Mechanic &#8211; Heavy Maintenance\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Complete large-scale structural repairs, intricate skin work, and critical disassembly tasks on commercial aircraft as part of broader work servicing,&hellip;","address":"Pensacola, FL, USA","location":{"lat":"30.4076647","city":"Pensacola","state":"FL","country":"United States","lng":"-87.2189746","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/sheet-metal-structures-mechanic-heavy-maintenance\/","zoom":19,"extra_fields":{"post_excerpt":"Complete large-scale structural repairs, intricate skin work, and critical disassembly tasks on commercial aircraft as part of broader work servicing,&hellip;","post_content":"<p>Complete large-scale structural repairs, intricate skin work, and critical disassembly tasks on commercial aircraft as part of broader work servicing, troubleshooting, repairing, modifying, and maintaining commercial aircraft. Complete work in accordance with policies, procedures, requirements, and specifications established by the company, applicable government agencies, and aircraft manufactures as contained in approved Maintenance Manuals.<\/p>\n\n<p>Minimum Requirements and Qualification<\/p>\n<p>1. Must have a valid driver\u2019s license.<\/p>\n<p>2. 3 years of relevant work experience with commercial heavy jets such as B747, B737, A 320, A330 in MRO setting<\/p>\n<p>3. Must have thorough working knowledge of all forms and documents required to support heavy maintenance service, including, but not limited to FAR\u2019s, AD\u2019s, Service Bulletins, and Maintenance Manuals.<\/p>\n<p>4. Proficient detail blueprint reading, ability to read, interpret and work from service bulletins, engineering work orders, major S.R.M. structural repairs, ability to layout work using bend radius, set back and bend allowance charts, utilization of shop math, knowledge of ATA codes, knowledge of all applicable F.A.R.\u2019s and company policies and procedures including job clocking procedures, routine\/ non-routine cards, and work sign-off\/ sell-off procedures<\/p>\n<p>5. Ability to complete large skin repairs requiring doublers \/ triplers containing complex contours<\/p>\n<p>6. Must be efficient in the use and application of tools, gauges, instruments, etc. necessary for the accomplishment of duties assigned.<\/p>\n<p>7. Must have an understanding and working knowledge of hazardous material handling and disposal as related to the job assignment.<\/p>\n<p>8. Must be able to obtain an airport SIDA badge (pass criminal background check)<\/p>\n<p>Major Responsibility Areas and Duties<\/p>\n<p>1. Works to written or verbal instructions.<\/p>\n<p>2. Performs all work assigned in accordance with approved maintenance procedures.<\/p>\n<p>3. Records work performed and assumes responsibility for that work as indicated by his\/her signature.<\/p>\n<p>4. Uses blueprints, schematics, technical drawings, and Maintenance Manuals in performance of assigned duties.<\/p>\n<p>5. Must have working knowledge and the ability to service troubleshoot, repair, modify, preserve, maintain, and overhaul aircraft, aircraft system, and aircraft components.<\/p>\n<p>Physical Requirements And Environmental Conditions<\/p>\n<p>1. Must be able to sit, stand, bend, crouch, kneel, and walk for extended periods.<\/p>\n<p>2. Must be able to climb and work from ladders, work stands, and other heights.<\/p>\n<p>3. Must be able to work with one or both hands extended overhead.<\/p>\n<p>4. Must have correctable near and far vision.<\/p>\n<p>5. Must be able to hear at conversational level with hearing aid.<\/p>\n<p>6. Must be able to lift 50 pounds.<\/p>\n<p>7. Must be able to handle and maintain control of small parts and to properly operate hand tools.<\/p>","post_title":"Sheet Metal \/ Structures Mechanic &#8211; Heavy Maintenance","post_link":"https:\/\/turnerstaffing.com\/position\/sheet-metal-structures-mechanic-heavy-maintenance\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"","%location_country%":"United States","%location_city%":"Pensacola","%location_state_id%":"FL","%location_state_name%":"Florida","%location_city_state%":"Pensacola, FL","%education%":"","%department%":"","%description%":"<p>Complete large-scale structural repairs, intricate skin work, and critical disassembly tasks on commercial aircraft as part of broader work servicing, troubleshooting, repairing, modifying, and maintaining commercial aircraft. Complete work in accordance with policies, procedures, requirements, and specifications established by the company, applicable government agencies, and aircraft manufactures as contained in approved Maintenance Manuals.<\/p>\n\n<p>Minimum Requirements and Qualification<\/p>\n<p>1. Must have a valid driver\u2019s license.<\/p>\n<p>2. 3 years of relevant work experience with commercial heavy jets such as B747, B737, A 320, A330 in MRO setting<\/p>\n<p>3. Must have thorough working knowledge of all forms and documents required to support heavy maintenance service, including, but not limited to FAR\u2019s, AD\u2019s, Service Bulletins, and Maintenance Manuals.<\/p>\n<p>4. Proficient detail blueprint reading, ability to read, interpret and work from service bulletins, engineering work orders, major S.R.M. structural repairs, ability to layout work using bend radius, set back and bend allowance charts, utilization of shop math, knowledge of ATA codes, knowledge of all applicable F.A.R.\u2019s and company policies and procedures including job clocking procedures, routine\/ non-routine cards, and work sign-off\/ sell-off procedures<\/p>\n<p>5. Ability to complete large skin repairs requiring doublers \/ triplers containing complex contours<\/p>\n<p>6. Must be efficient in the use and application of tools, gauges, instruments, etc. necessary for the accomplishment of duties assigned.<\/p>\n<p>7. Must have an understanding and working knowledge of hazardous material handling and disposal as related to the job assignment.<\/p>\n<p>8. Must be able to obtain an airport SIDA badge (pass criminal background check)<\/p>\n<p>Major Responsibility Areas and Duties<\/p>\n<p>1. Works to written or verbal instructions.<\/p>\n<p>2. Performs all work assigned in accordance with approved maintenance procedures.<\/p>\n<p>3. Records work performed and assumes responsibility for that work as indicated by his\/her signature.<\/p>\n<p>4. Uses blueprints, schematics, technical drawings, and Maintenance Manuals in performance of assigned duties.<\/p>\n<p>5. Must have working knowledge and the ability to service troubleshoot, repair, modify, preserve, maintain, and overhaul aircraft, aircraft system, and aircraft components.<\/p>\n<p>Physical Requirements And Environmental Conditions<\/p>\n<p>1. Must be able to sit, stand, bend, crouch, kneel, and walk for extended periods.<\/p>\n<p>2. Must be able to climb and work from ladders, work stands, and other heights.<\/p>\n<p>3. Must be able to work with one or both hands extended overhead.<\/p>\n<p>4. Must have correctable near and far vision.<\/p>\n<p>5. Must be able to hear at conversational level with hearing aid.<\/p>\n<p>6. Must be able to lift 50 pounds.<\/p>\n<p>7. Must be able to handle and maintain control of small parts and to properly operate hand tools.<\/p>","%category%":"","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/3c7755451da0-sheet-metal-structures-mechanic-heavy-maintenance","%breezy_id%":"3c7755451da0","%breezy_friendly_id%":"3c7755451da0-sheet-metal-structures-mechanic-heavy-maintenance","%breezy_created_date%":"2025-08-04T15:19:54.751Z","%breezy_updated_date%":"2025-08-04T15:22:09.542Z","%_wpgmp_location_city%":"Pensacola","%_wpgmp_location_state%":"FL","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Pensacola, FL, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"30.4076647","%_wpgmp_metabox_longitude%":"-87.2189746","%rank_math_internal_links_processed%":"1"}},"id":2663,"infowindow_disable":false},{"source":"post","title":"Welder &#8211; Structural Welding","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Welder &#8211; Structural Welding\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Job Summary: We are seeking an experienced and safety-conscious Welder with strong structural welding expertise to join our growing grading&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/welder-structural-welding\/\" name=\"Welder &#8211; Structural Welding\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Job Summary: We are seeking an experienced and safety-conscious Welder with strong structural welding expertise to join our growing grading&hellip;","address":"Atlanta, GA, USA","location":{"lat":"33.7501275","city":"Atlanta","state":"GA","country":"United States","lng":"-84.3885209","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/welder-structural-welding\/","zoom":19,"extra_fields":{"post_excerpt":"Job Summary: We are seeking an experienced and safety-conscious Welder with strong structural welding expertise to join our growing grading&hellip;","post_content":"<p>Job Summary:<\/p>\n<p>We are seeking an experienced and safety-conscious Welder with strong structural welding<\/p>\n<p>expertise to join our growing grading and utilities team. This role is responsible for fabricating,<\/p>\n<p>repairing, and installing structural steel components for heavy civil construction projects,<\/p>\n<p>including earthmoving equipment, utility structures, retaining systems, trench shoring, and other<\/p>\n<p>critical site infrastructure. Candidates must be comfortable working in shop and field<\/p>\n<p>environments.<\/p>\n<p>Key Responsibilities:<\/p>\n<p>\uf0b7 Perform MIG, TIG, Stick, and Flux Core welding on steel and structural components.<\/p>\n<p>\uf0b7 Fabricate and assemble structural frames, supports, utility brackets, and site structures<\/p>\n<p>based on engineered drawings and specs.<\/p>\n<p>\uf0b7 Inspect, maintain, and repair construction equipment and attachments (buckets, blades,<\/p>\n<p>rippers, etc.).<\/p>\n<p>\uf0b7 Weld on pipe and steel for stormwater, sewer, water, and utility infrastructure as needed.<\/p>\n<p>\uf0b7 Ensure proper joint preparation, alignment, and weld quality.<\/p>\n<p>\uf0b7 Operate cutting torches, plasma cutters, grinders, and other metalworking tools.<\/p>\n<p>\uf0b7 Work from blueprints, schematics, and verbal instructions.<\/p>\n<p>\uf0b7 Follow OSHA safety protocols and company standards at all times.<\/p>\n<p>\uf0b7 Assist with field welding repairs and mobile welding on job sites.<\/p>\n<p>\uf0b7 Maintain equipment logs and welding certifications.<\/p>\n<p>Qualifications:<\/p>\n<p>\uf0b7 3+ years of welding experience in construction, preferably grading or utilities.<\/p>\n<p>\uf0b7 Proven experience welding structural steel to AWS D1.1 or similar standards.<\/p>\n<p>\uf0b7 Ability to read and interpret structural blueprints and fabrication drawings.<\/p>\n<p>\uf0b7 Skilled with all primary welding methods (MIG, Stick, TIG, Flux Core).<\/p>\n<p>\uf0b7 Familiarity with utility infrastructure, heavy equipment, and field fabrication.<\/p>\n<p>\uf0b7 Must be able to work in outdoor environments and tight spaces when needed.<\/p>\n<p>\uf0b7 Possess or willing to obtain OSHA 10 or 30 certification.<\/p>\n<p>\uf0b7 Valid driver\u2019s license; CDL is a plus.<\/p>\n<p>\uf0b7 Certification in structural welding preferred (AWS or similar).<\/p>\n<p>Physical Requirements:<\/p>\n<p>\uf0b7 Ability to lift 50+ lbs.<\/p>\n<p>\uf0b7 Comfortable working in hot, cold, muddy, or uneven terrain.<\/p>\n<p>\uf0b7 Able to stand, bend, kneel, and climb for extended periods.<\/p>\n<p>Preferred Traits:<\/p>\n<p>\uf0b7 Strong attention to detail and pride in workmanship.<\/p>\n<p>\uf0b7 Dependable, safety-minded, and team-oriented.<\/p>\n<p>\uf0b7 Self-starter with the ability to work with minimal supervision.<\/p>","post_title":"Welder &#8211; Structural Welding","post_link":"https:\/\/turnerstaffing.com\/position\/welder-structural-welding\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Mid Level","%location_country%":"United States","%location_city%":"Atlanta","%location_state_id%":"GA","%location_state_name%":"Georgia","%location_city_state%":"Atlanta, GA","%education%":"Unspecified","%department%":"","%description%":"<p>Job Summary:<\/p>\n<p>We are seeking an experienced and safety-conscious Welder with strong structural welding<\/p>\n<p>expertise to join our growing grading and utilities team. This role is responsible for fabricating,<\/p>\n<p>repairing, and installing structural steel components for heavy civil construction projects,<\/p>\n<p>including earthmoving equipment, utility structures, retaining systems, trench shoring, and other<\/p>\n<p>critical site infrastructure. Candidates must be comfortable working in shop and field<\/p>\n<p>environments.<\/p>\n<p>Key Responsibilities:<\/p>\n<p>\uf0b7 Perform MIG, TIG, Stick, and Flux Core welding on steel and structural components.<\/p>\n<p>\uf0b7 Fabricate and assemble structural frames, supports, utility brackets, and site structures<\/p>\n<p>based on engineered drawings and specs.<\/p>\n<p>\uf0b7 Inspect, maintain, and repair construction equipment and attachments (buckets, blades,<\/p>\n<p>rippers, etc.).<\/p>\n<p>\uf0b7 Weld on pipe and steel for stormwater, sewer, water, and utility infrastructure as needed.<\/p>\n<p>\uf0b7 Ensure proper joint preparation, alignment, and weld quality.<\/p>\n<p>\uf0b7 Operate cutting torches, plasma cutters, grinders, and other metalworking tools.<\/p>\n<p>\uf0b7 Work from blueprints, schematics, and verbal instructions.<\/p>\n<p>\uf0b7 Follow OSHA safety protocols and company standards at all times.<\/p>\n<p>\uf0b7 Assist with field welding repairs and mobile welding on job sites.<\/p>\n<p>\uf0b7 Maintain equipment logs and welding certifications.<\/p>\n<p>Qualifications:<\/p>\n<p>\uf0b7 3+ years of welding experience in construction, preferably grading or utilities.<\/p>\n<p>\uf0b7 Proven experience welding structural steel to AWS D1.1 or similar standards.<\/p>\n<p>\uf0b7 Ability to read and interpret structural blueprints and fabrication drawings.<\/p>\n<p>\uf0b7 Skilled with all primary welding methods (MIG, Stick, TIG, Flux Core).<\/p>\n<p>\uf0b7 Familiarity with utility infrastructure, heavy equipment, and field fabrication.<\/p>\n<p>\uf0b7 Must be able to work in outdoor environments and tight spaces when needed.<\/p>\n<p>\uf0b7 Possess or willing to obtain OSHA 10 or 30 certification.<\/p>\n<p>\uf0b7 Valid driver\u2019s license; CDL is a plus.<\/p>\n<p>\uf0b7 Certification in structural welding preferred (AWS or similar).<\/p>\n<p>Physical Requirements:<\/p>\n<p>\uf0b7 Ability to lift 50+ lbs.<\/p>\n<p>\uf0b7 Comfortable working in hot, cold, muddy, or uneven terrain.<\/p>\n<p>\uf0b7 Able to stand, bend, kneel, and climb for extended periods.<\/p>\n<p>Preferred Traits:<\/p>\n<p>\uf0b7 Strong attention to detail and pride in workmanship.<\/p>\n<p>\uf0b7 Dependable, safety-minded, and team-oriented.<\/p>\n<p>\uf0b7 Self-starter with the ability to work with minimal supervision.<\/p>","%category%":"Operations","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/da41d3c84005-welder-structural-welding","%breezy_id%":"da41d3c84005","%breezy_friendly_id%":"da41d3c84005-welder-structural-welding","%breezy_created_date%":"2025-07-17T14:11:59.470Z","%breezy_updated_date%":"2025-08-04T10:46:53.906Z","%_wpgmp_location_city%":"Atlanta","%_wpgmp_location_state%":"GA","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Atlanta, GA, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"33.7501275","%_wpgmp_metabox_longitude%":"-84.3885209","%rank_math_internal_links_processed%":"1"}},"id":2662,"infowindow_disable":false},{"source":"post","title":"Land Management Specialist","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Land Management Specialist\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    We are seeking a motivated and skilled Land Management Specialist to join our team, responsible for ensuring the successful implementation&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/land-management-specialist\/\" name=\"Land Management Specialist\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"We are seeking a motivated and skilled Land Management Specialist to join our team, responsible for ensuring the successful implementation&hellip;","address":"Yadkinville, NC, USA","location":{"lat":"36.1345807","city":"Yadkinville","state":"NC","country":"United States","lng":"-80.6595079","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/land-management-specialist\/","zoom":19,"extra_fields":{"post_excerpt":"We are seeking a motivated and skilled Land Management Specialist to join our team, responsible for ensuring the successful implementation&hellip;","post_content":"<p>We are seeking a motivated and skilled Land Management Specialist to join our team, responsible for ensuring the successful implementation of land restoration, erosion control, and habitat management projects. This role requires a combination of hands-on fieldwork, equipment operation, and leadership skills, along with a deep understanding of land management practices, environmental restoration, and ecological best practices.<\/p>\n<p>As a Land Management Specialist, you will be responsible for overseeing and executing field operations, operating a wide variety of equipment, and ensuring that all tasks are completed safely, on time, and according to project specifications. This position requires both technical skills and the ability to work in a dynamic, fast-paced outdoor environment.<\/p>\n<p><strong>Key Responsibilities:<\/strong><\/p>\n<p><em>Equipment Operation:<\/em><\/p>\n<ul>\n <li>Safely      operate and maintain a range of equipment, including 75hp to 140hp      tractors, 10-ton to 20-ton excavators, skid steers, seed drills, and      various tractor and skid steer attachments.<\/li>\n <li>Operate      small off-road trucks, four-wheelers, UTVs, company trucks, and both small      and large trailers to transport equipment and materials to and from job      sites.<\/li>\n <li>Ensure      proper maintenance and upkeep of all vehicles and machinery.<\/li>\n<\/ul>\n<p><em>Fieldwork and Installation:<\/em><\/p>\n<ul>\n <li>Install      silt fencing to control erosion on job sites.<\/li>\n <li>Apply      various types of seed, fertilizer, and lime in accordance with planting      and seeding plans.<\/li>\n <li>Perform      straw blowing, shaking, and other erosion control tasks.<\/li>\n <li>Build      and repair fences, including woven wire, high tensile, and barbed wire.<\/li>\n <li>Perform      chainsaw work and operate weed trimmers for vegetation management and land      clearing.<\/li>\n <li>Plant      a variety of plant species, including hardwoods, herbaceous plugs, bare      roots, and live stakes, in accordance with planting plans.<\/li>\n<\/ul>\n<p><em>Site Preparation and Management:<\/em><\/p>\n<ul>\n <li>Install      erosion control matting, geo textiles, and other materials to prevent soil      erosion and enhance vegetation growth.<\/li>\n <li>Read      and interpret planting and seeding plans to ensure all work is completed      to specifications.<\/li>\n <li>Schedule      crews and coordinate daily tasks in the field, ensuring efficient project      timelines (typically scheduling crews one week in advance).<\/li>\n<\/ul>\n<p><em>Invasive Species Control and Spraying:<\/em><\/p>\n<ul>\n <li>Identify      and remove invasive species, applying appropriate control methods.<\/li>\n <li>Safely      apply herbicides and pesticides when needed, adhering to all safety      regulations.<\/li>\n<\/ul>\n<p><em>Team Leadership and Communication:<\/em><\/p>\n<ul>\n <li>Supervise      and lead field crews, ensuring productivity, safety, and high-quality      workmanship.<\/li>\n <li>Communicate      effectively with supervisors, project managers, and clients to provide      updates on project progress and resolve issues in a timely manner.<\/li>\n <li>Travel      to various job sites as needed, often requiring overnight stays or long      hours in the field.<\/li>\n<\/ul>\n<p><em>Additional Requirements:<\/em><\/p>\n<ul>\n <li>Knowledge      of erosion control and land restoration techniques, as well as      environmental and ecological best practices.<\/li>\n <li>Ability      to speak Spanish is a plus, but not required.<\/li>\n <li>Must      be able to work independently or as part of a team, showing strong      initiative and problem-solving skills.<\/li>\n<\/ul>\n<p><strong>Qualifications:<\/strong><\/p>\n<ul>\n <li>Prior      experience operating heavy equipment (tractors, excavators, skid steers,      etc.) and working in the field is highly preferred.<\/li>\n <li>Strong      knowledge of land management practices, erosion control, habitat      restoration, and ecological restoration.<\/li>\n <li>Ability      to read and interpret land management plans, including planting and      seeding designs.<\/li>\n <li>Experience      in invasive species removal, spraying, and general land stewardship      practices.<\/li>\n <li>Must      be comfortable working in varying weather conditions and be physically fit      for outdoor work.<\/li>\n <li>Valid      driver\u2019s license is required.<\/li>\n <li>Ability      to travel as needed for job sites.<\/li>\n<\/ul>\n<p>If you're passionate about environmental restoration, possess strong equipment-operating skills, and enjoy working outdoors in a collaborative team environment, we encourage you to apply for the Land Management Specialist position.<\/p>","post_title":"Land Management Specialist","post_link":"https:\/\/turnerstaffing.com\/position\/land-management-specialist\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Mid Level","%location_country%":"United States","%location_city%":"Yadkinville","%location_state_id%":"NC","%location_state_name%":"North Carolina","%location_city_state%":"Yadkinville, NC","%education%":"Unspecified","%department%":"","%description%":"<p>We are seeking a motivated and skilled Land Management Specialist to join our team, responsible for ensuring the successful implementation of land restoration, erosion control, and habitat management projects. This role requires a combination of hands-on fieldwork, equipment operation, and leadership skills, along with a deep understanding of land management practices, environmental restoration, and ecological best practices.<\/p>\n<p>As a Land Management Specialist, you will be responsible for overseeing and executing field operations, operating a wide variety of equipment, and ensuring that all tasks are completed safely, on time, and according to project specifications. This position requires both technical skills and the ability to work in a dynamic, fast-paced outdoor environment.<\/p>\n<p><strong>Key Responsibilities:<\/strong><\/p>\n<p><em>Equipment Operation:<\/em><\/p>\n<ul>\n <li>Safely      operate and maintain a range of equipment, including 75hp to 140hp      tractors, 10-ton to 20-ton excavators, skid steers, seed drills, and      various tractor and skid steer attachments.<\/li>\n <li>Operate      small off-road trucks, four-wheelers, UTVs, company trucks, and both small      and large trailers to transport equipment and materials to and from job      sites.<\/li>\n <li>Ensure      proper maintenance and upkeep of all vehicles and machinery.<\/li>\n<\/ul>\n<p><em>Fieldwork and Installation:<\/em><\/p>\n<ul>\n <li>Install      silt fencing to control erosion on job sites.<\/li>\n <li>Apply      various types of seed, fertilizer, and lime in accordance with planting      and seeding plans.<\/li>\n <li>Perform      straw blowing, shaking, and other erosion control tasks.<\/li>\n <li>Build      and repair fences, including woven wire, high tensile, and barbed wire.<\/li>\n <li>Perform      chainsaw work and operate weed trimmers for vegetation management and land      clearing.<\/li>\n <li>Plant      a variety of plant species, including hardwoods, herbaceous plugs, bare      roots, and live stakes, in accordance with planting plans.<\/li>\n<\/ul>\n<p><em>Site Preparation and Management:<\/em><\/p>\n<ul>\n <li>Install      erosion control matting, geo textiles, and other materials to prevent soil      erosion and enhance vegetation growth.<\/li>\n <li>Read      and interpret planting and seeding plans to ensure all work is completed      to specifications.<\/li>\n <li>Schedule      crews and coordinate daily tasks in the field, ensuring efficient project      timelines (typically scheduling crews one week in advance).<\/li>\n<\/ul>\n<p><em>Invasive Species Control and Spraying:<\/em><\/p>\n<ul>\n <li>Identify      and remove invasive species, applying appropriate control methods.<\/li>\n <li>Safely      apply herbicides and pesticides when needed, adhering to all safety      regulations.<\/li>\n<\/ul>\n<p><em>Team Leadership and Communication:<\/em><\/p>\n<ul>\n <li>Supervise      and lead field crews, ensuring productivity, safety, and high-quality      workmanship.<\/li>\n <li>Communicate      effectively with supervisors, project managers, and clients to provide      updates on project progress and resolve issues in a timely manner.<\/li>\n <li>Travel      to various job sites as needed, often requiring overnight stays or long      hours in the field.<\/li>\n<\/ul>\n<p><em>Additional Requirements:<\/em><\/p>\n<ul>\n <li>Knowledge      of erosion control and land restoration techniques, as well as      environmental and ecological best practices.<\/li>\n <li>Ability      to speak Spanish is a plus, but not required.<\/li>\n <li>Must      be able to work independently or as part of a team, showing strong      initiative and problem-solving skills.<\/li>\n<\/ul>\n<p><strong>Qualifications:<\/strong><\/p>\n<ul>\n <li>Prior      experience operating heavy equipment (tractors, excavators, skid steers,      etc.) and working in the field is highly preferred.<\/li>\n <li>Strong      knowledge of land management practices, erosion control, habitat      restoration, and ecological restoration.<\/li>\n <li>Ability      to read and interpret land management plans, including planting and      seeding designs.<\/li>\n <li>Experience      in invasive species removal, spraying, and general land stewardship      practices.<\/li>\n <li>Must      be comfortable working in varying weather conditions and be physically fit      for outdoor work.<\/li>\n <li>Valid      driver\u2019s license is required.<\/li>\n <li>Ability      to travel as needed for job sites.<\/li>\n<\/ul>\n<p>If you're passionate about environmental restoration, possess strong equipment-operating skills, and enjoy working outdoors in a collaborative team environment, we encourage you to apply for the Land Management Specialist position.<\/p>","%category%":"Operations","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/1bd48fd95eac-land-management-specialist","%breezy_id%":"1bd48fd95eac","%breezy_friendly_id%":"1bd48fd95eac-land-management-specialist","%breezy_created_date%":"2025-01-31T19:19:37.909Z","%breezy_updated_date%":"2025-08-04T16:58:53.106Z","%_wpgmp_location_city%":"Yadkinville","%_wpgmp_location_state%":"NC","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Yadkinville, NC, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"36.1345807","%_wpgmp_metabox_longitude%":"-80.6595079","%rank_math_internal_links_processed%":"1"}},"id":2661,"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-08-01T13:25:15.479Z","%_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":"Loader Operator &#8211; CAT 988\/990","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Loader Operator &#8211; CAT 988\/990\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Looking to hire an operator who can operate a CAT 988\/990 loader to load haul trucks.&nbsp; Responsibilities: &#8211; Operate heavy&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/loader-operator-cat-988-990\/\" name=\"Loader Operator &#8211; CAT 988\/990\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Looking to hire an operator who can operate a CAT 988\/990 loader to load haul trucks.&nbsp; Responsibilities: &#8211; Operate heavy&hellip;","address":"Bridgeport, TX, USA","location":{"lat":"33.2101155","city":"Bridgeport","state":"TX","country":"United States","lng":"-97.7547552","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/loader-operator-cat-988-990\/","zoom":19,"extra_fields":{"post_excerpt":"Looking to hire an operator who can operate a CAT 988\/990 loader to load haul trucks.&nbsp; Responsibilities: &#8211; Operate heavy&hellip;","post_content":"<p>Looking to hire an operator who can operate a CAT 988\/990 loader to load haul trucks.&nbsp;<br><br>Responsibilities:<br><br>- Operate heavy equipment to move materials, run a riprap plant,&nbsp;load, and unload trucks, and prepare job sites<br><br>- Perform routine maintenance on equipment and ensure proper operation<br><br>- Communicate effectively with team members and supervisors<br><br>- Follow safety guidelines and protocols at all ties<br><br>- Work efficiently to meet project deadlines<\/p>","post_title":"Loader Operator &#8211; CAT 988\/990","post_link":"https:\/\/turnerstaffing.com\/position\/loader-operator-cat-988-990\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"","%location_country%":"United States","%location_city%":"Bridgeport","%location_state_id%":"TX","%location_state_name%":"Texas","%location_city_state%":"Bridgeport, TX","%education%":"","%department%":"","%description%":"<p>Looking to hire an operator who can operate a CAT 988\/990 loader to load haul trucks.&nbsp;<br><br>Responsibilities:<br><br>- Operate heavy equipment to move materials, run a riprap plant,&nbsp;load, and unload trucks, and prepare job sites<br><br>- Perform routine maintenance on equipment and ensure proper operation<br><br>- Communicate effectively with team members and supervisors<br><br>- Follow safety guidelines and protocols at all ties<br><br>- Work efficiently to meet project deadlines<\/p>","%category%":"","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/c04f8a0dbe3f-loader-operator-cat-988-990","%breezy_id%":"c04f8a0dbe3f","%breezy_friendly_id%":"c04f8a0dbe3f-loader-operator-cat-988-990","%breezy_created_date%":"2024-12-03T21:36:06.679Z","%breezy_updated_date%":"2025-08-01T18:27:22.848Z","%_wpgmp_location_city%":"Bridgeport","%_wpgmp_location_state%":"TX","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Bridgeport, TX, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"33.2101155","%_wpgmp_metabox_longitude%":"-97.7547552","%rank_math_internal_links_processed%":"1"}},"id":2649,"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    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=\"Senior Mining Engineer\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Project Engineer Advisor to Project Management Reports to Project Manager Reporting to the Project Manager, the Project Engineer plays a&hellip;","address":"Kingman, AZ, USA","location":{"lat":"35.1912977","city":"Kingman","state":"AZ","country":"United States","lng":"-114.0522845","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/project-engineer-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<p>\u2022 Review operational reports (cost, safety, production) and analyze data for key trends.<\/p>\n<p>\u2022 Develop and implement continuous improvement initiatives to enhance efficiency and reduce costs.<\/p>\n<p>\u2022 Conduct risk assessments for operational, technical, and financial aspects of mining projects.<\/p>\n<p>\u2022 Collaborate with engineering and operations teams to optimize mine planning, design, and extraction techniques.<\/p>\n<p>\u2022 Develop and track key performance indicators (KPIs) to monitor operational performance and drive improvements.<\/p>\n<p><strong>Mine Engineering &amp; Survey Duties<\/strong><\/p>\n<p>\u2022 Manage fleet management and high precision GPS systems.<\/p>\n<p>\u2022 Develop Drill &amp; Blast pattern, profile, and timing designs and short-range plans.<\/p>\n<p>\u2022 Produce road designs, stockpile and waste storage designs, and others in Hexagon MineSight.<\/p>\n<p>\u2022 Operate survey drones and reconcile results.<\/p>\n<p>\u2022 Analyze FMS and other data for risks and opportunities.<\/p>\n<p>\u2022 Audit and advise client on short range mine plans.<\/p>\n<p><strong>Client &amp; Cross-Functional Collaboration<\/strong><\/p>\n<p>\u2022 Work closely with Turner Mining departments and external stakeholders to define project scopes and execution strategies.<\/p>\n<p>\u2022 Act as a technical link between client technical services and project management to ensure alignment on operational objectives.<\/p>\n<p>\u2022 Participate in knowledge-sharing initiatives, such as internal workshops and training, to support operational and analytical capabilities across teams.<\/p>\n<p>\u2022 Engage with suppliers and service providers to optimize procurement strategies for project operations.<\/p>\n<p><strong>Compliance and Safety Integration<\/strong><\/p>\n<p>\u2022 Ensure that all engineering recommendations align with MSHA safety regulations and industry best practices.<\/p>\n<p>\u2022 Develop and maintain standard operating procedures (SOPs) for operational and safety processes.<\/p>\n<p>\u2022 Provide technical guidance to ensure site compliance with environmental and regulatory requirements.<\/p>\n<p><strong><u>Other duties as required.<\/u><\/strong><\/p>\n<p><strong>The Ideal Candidate:<\/strong><\/p>\n<p><strong>Education and Experience<\/strong><\/p>\n<p>\u2022 Mining or Civil Engineering Degree or related.<\/p>\n<p>\u2022 3 years of mine site engineering or operational experience.<\/p>\n<p>\u2022 Hands-on experience with mining engineering software (Hexagon MineSight preferred or similar).<\/p>\n<p>\u2022 Strong proficiency in MS Office (Word, Excel, PowerPoint, Outlook).<\/p>\n<p>\u2022 Part 107 drone license preferred<\/p>\n<p>\u2022 Procurement and mine accounting experience preferred<\/p>\n<p><strong>Technical and Analytical Skills<\/strong><\/p>\n<p>\u2022 Strong problem-solving and data analysis capabilities.<\/p>\n<p>\u2022 Ability to translate complex engineering data into actionable recommendations.<\/p>\n<p>\u2022 Knowledge of drill &amp; blast design, mine haulage analysis, and GPS fleet management.<\/p>\n<p>\u2022 Familiarity with mine accounting and procurement processes (preferred but not required).<\/p>\n<p><strong>Key Competencies \/ Skills<\/strong><\/p>\n<p>\u2022 Results-oriented with a proactive, problem-solving mindset.<\/p>\n<p>\u2022 Effective communicator, capable of working with cross-functional teams and clients.<\/p>\n<p>\u2022 Ability to work independently and manage multiple priorities in a dynamic environment.<\/p>\n<p>\u2022 Detail-oriented with strong documentation and technical writing skills.<\/p>","post_title":"Senior Mining Engineer","post_link":"https:\/\/turnerstaffing.com\/position\/project-engineer-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%":"Bachelor's Degree","%department%":"Engineering","%description%":"<p><strong><u>Project Engineer<\/u><\/strong><\/p>\n<p><strong>Advisor to Project Management<\/strong><\/p>\n<p><strong>Reports to Project Manager<\/strong><\/p>\n<p>Reporting to the Project Manager, the Project Engineer plays a crucial role in bridging technical mining expertise with mining operations by providing insights through engineering guidance, driving operational efficiency, financial accountability, and long-term project success. This position is responsible for analyzing operational data, preparing engineering designs\/operational GPS support, conducting field data collection, and production forecasting.<\/p>\n<p>By integrating engineering principles, the role provides support for optimizing mining operations, identifying cost-saving opportunities, and evaluating potential efficiency improvements. Additionally, it involves collaboration with Turner Mining Group and client teams, ensuring alignment between corporate objectives, site-level execution, and regulatory compliance.<\/p>\n<p>This role requires a strong operational mindset, familiar with MSHA safety guidelines, industry knowledge, and the ability to analyze complex data into actionable recommendations. With a focus on continuous improvement, efficiency, and project execution, the Project Engineer is integral to enhancing both operational performance and efficiency at Turner Mining Group.<\/p>\n<p><strong><u>Position Responsibilities:<\/u><\/strong><\/p>\n<p><strong>Operational &amp; Technical Analysis<\/strong><\/p>\n<p>\u2022 Review operational reports (cost, safety, production) and analyze data for key trends.<\/p>\n<p>\u2022 Develop and implement continuous improvement initiatives to enhance efficiency and reduce costs.<\/p>\n<p>\u2022 Conduct risk assessments for operational, technical, and financial aspects of mining projects.<\/p>\n<p>\u2022 Collaborate with engineering and operations teams to optimize mine planning, design, and extraction techniques.<\/p>\n<p>\u2022 Develop and track key performance indicators (KPIs) to monitor operational performance and drive improvements.<\/p>\n<p><strong>Mine Engineering &amp; Survey Duties<\/strong><\/p>\n<p>\u2022 Manage fleet management and high precision GPS systems.<\/p>\n<p>\u2022 Develop Drill &amp; Blast pattern, profile, and timing designs and short-range plans.<\/p>\n<p>\u2022 Produce road designs, stockpile and waste storage designs, and others in Hexagon MineSight.<\/p>\n<p>\u2022 Operate survey drones and reconcile results.<\/p>\n<p>\u2022 Analyze FMS and other data for risks and opportunities.<\/p>\n<p>\u2022 Audit and advise client on short range mine plans.<\/p>\n<p><strong>Client &amp; Cross-Functional Collaboration<\/strong><\/p>\n<p>\u2022 Work closely with Turner Mining departments and external stakeholders to define project scopes and execution strategies.<\/p>\n<p>\u2022 Act as a technical link between client technical services and project management to ensure alignment on operational objectives.<\/p>\n<p>\u2022 Participate in knowledge-sharing initiatives, such as internal workshops and training, to support operational and analytical capabilities across teams.<\/p>\n<p>\u2022 Engage with suppliers and service providers to optimize procurement strategies for project operations.<\/p>\n<p><strong>Compliance and Safety Integration<\/strong><\/p>\n<p>\u2022 Ensure that all engineering recommendations align with MSHA safety regulations and industry best practices.<\/p>\n<p>\u2022 Develop and maintain standard operating procedures (SOPs) for operational and safety processes.<\/p>\n<p>\u2022 Provide technical guidance to ensure site compliance with environmental and regulatory requirements.<\/p>\n<p><strong><u>Other duties as required.<\/u><\/strong><\/p>\n<p><strong>The Ideal Candidate:<\/strong><\/p>\n<p><strong>Education and Experience<\/strong><\/p>\n<p>\u2022 Mining or Civil Engineering Degree or related.<\/p>\n<p>\u2022 3 years of mine site engineering or operational experience.<\/p>\n<p>\u2022 Hands-on experience with mining engineering software (Hexagon MineSight preferred or similar).<\/p>\n<p>\u2022 Strong proficiency in MS Office (Word, Excel, PowerPoint, Outlook).<\/p>\n<p>\u2022 Part 107 drone license preferred<\/p>\n<p>\u2022 Procurement and mine accounting experience preferred<\/p>\n<p><strong>Technical and Analytical Skills<\/strong><\/p>\n<p>\u2022 Strong problem-solving and data analysis capabilities.<\/p>\n<p>\u2022 Ability to translate complex engineering data into actionable recommendations.<\/p>\n<p>\u2022 Knowledge of drill &amp; blast design, mine haulage analysis, and GPS fleet management.<\/p>\n<p>\u2022 Familiarity with mine accounting and procurement processes (preferred but not required).<\/p>\n<p><strong>Key Competencies \/ Skills<\/strong><\/p>\n<p>\u2022 Results-oriented with a proactive, problem-solving mindset.<\/p>\n<p>\u2022 Effective communicator, capable of working with cross-functional teams and clients.<\/p>\n<p>\u2022 Ability to work independently and manage multiple priorities in a dynamic environment.<\/p>\n<p>\u2022 Detail-oriented with strong documentation and technical writing skills.<\/p>","%category%":"Operations","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/94e7660230d4-senior-mining-engineer","%breezy_id%":"94e7660230d4","%breezy_friendly_id%":"94e7660230d4-senior-mining-engineer","%breezy_created_date%":"2025-07-31T13:26:20.042Z","%breezy_updated_date%":"2025-08-13T13:31:02.195Z","%_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":2644,"infowindow_disable":false},{"source":"post","title":"Senior Electrical Project Manager","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Senior Electrical Project Manager\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Our client&nbsp;is currently seeking a Senior Project Manager for an immediate opening in Cedar Rapids, IA. The Senior Project Manager&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/senior-electrical-project-manager-2\/\" name=\"Senior Electrical Project Manager\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Our client&nbsp;is currently seeking a Senior Project Manager for an immediate opening in Cedar Rapids, IA. The Senior Project Manager&hellip;","address":"Cedar Rapids, IA, USA","location":{"lat":"41.9778795","city":"Cedar Rapids","state":"IA","country":"United States","lng":"-91.6656232","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/senior-electrical-project-manager-2\/","zoom":19,"extra_fields":{"post_excerpt":"Our client&nbsp;is currently seeking a Senior Project Manager for an immediate opening in Cedar Rapids, IA. The Senior Project Manager&hellip;","post_content":"<p>Our client&nbsp;is currently seeking a Senior Project Manager for an immediate opening in Cedar Rapids, IA. The Senior Project Manager will be responsible for providing&nbsp;overall on-site administrative and technical management on mission critical construction projects for our electrical division.&nbsp;<\/p>\n<p>Responsibilities include but are not limited to:<\/p>\n<ul><li>Supervising total construction effort to ensure project is constructed in accordance with design, budget, and schedule (includes interfacing with customer representatives, A-E representatives, other contractors, etc.)<\/li><li>Planning, coordinating, and supervising on-site functions (scheduling, engineering, material control, and may provide day-to-day direction of on-site administrative staff in accounting, purchasing, etc.)<\/li><li>Supervising craft employees and\/or other contractors as required by the contract<\/li><li>Providing technical assistance, e.g. interpretation of drawings, recommending construction methods and equipment, etc., as required<\/li><li>Initiating and providing extra work estimating and issuance of change orders<\/li><li>Assuming responsibility for productivity of crafts, efficient use of materials and equipment, and contractual performance of the project<\/li><li>Fostering and maintaining good morale and positive relationships with customers, field and\/or office personnel<\/li><li>Participating as a team in calling on and selling customers on potential project<\/li><li>Performing additional assignments per management\u2019s direction<\/li><\/ul>\n<p>Qualifications:<\/p>\n<ul><li>Bachelor\u2019s Degree in Business, Finance, Construction Management, or related industry<\/li><li>10+ years of related experience<\/li><li>Equivalent combination of education\/experience<\/li><\/ul>\n<p>Candidates must possess strong attention to detail, focus on accuracy, solid communication skills, a strong mechanical aptitude, positive initiative and judgement, the ability to problem solve and meet deadlines and the ability to multitask with tact and consideration.<\/p>","post_title":"Senior Electrical Project Manager","post_link":"https:\/\/turnerstaffing.com\/position\/senior-electrical-project-manager-2\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Senior","%location_country%":"United States","%location_city%":"Cedar Rapids","%location_state_id%":"IA","%location_state_name%":"Iowa","%location_city_state%":"Cedar Rapids, IA","%education%":"Bachelor's Degree","%department%":"","%description%":"<p>Our client&nbsp;is currently seeking a Senior Project Manager for an immediate opening in Cedar Rapids, IA. The Senior Project Manager will be responsible for providing&nbsp;overall on-site administrative and technical management on mission critical construction projects for our electrical division.&nbsp;<\/p>\n<p>Responsibilities include but are not limited to:<\/p>\n<ul><li>Supervising total construction effort to ensure project is constructed in accordance with design, budget, and schedule (includes interfacing with customer representatives, A-E representatives, other contractors, etc.)<\/li><li>Planning, coordinating, and supervising on-site functions (scheduling, engineering, material control, and may provide day-to-day direction of on-site administrative staff in accounting, purchasing, etc.)<\/li><li>Supervising craft employees and\/or other contractors as required by the contract<\/li><li>Providing technical assistance, e.g. interpretation of drawings, recommending construction methods and equipment, etc., as required<\/li><li>Initiating and providing extra work estimating and issuance of change orders<\/li><li>Assuming responsibility for productivity of crafts, efficient use of materials and equipment, and contractual performance of the project<\/li><li>Fostering and maintaining good morale and positive relationships with customers, field and\/or office personnel<\/li><li>Participating as a team in calling on and selling customers on potential project<\/li><li>Performing additional assignments per management\u2019s direction<\/li><\/ul>\n<p>Qualifications:<\/p>\n<ul><li>Bachelor\u2019s Degree in Business, Finance, Construction Management, or related industry<\/li><li>10+ years of related experience<\/li><li>Equivalent combination of education\/experience<\/li><\/ul>\n<p>Candidates must possess strong attention to detail, focus on accuracy, solid communication skills, a strong mechanical aptitude, positive initiative and judgement, the ability to problem solve and meet deadlines and the ability to multitask with tact and consideration.<\/p>","%category%":"Management","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/5deb8cf4c9b4-senior-electrical-project-manager","%breezy_id%":"5deb8cf4c9b4","%breezy_friendly_id%":"5deb8cf4c9b4-senior-electrical-project-manager","%breezy_created_date%":"2025-02-06T21:47:19.946Z","%breezy_updated_date%":"2025-07-31T13:12:31.424Z","%_wpgmp_location_city%":"Cedar Rapids","%_wpgmp_location_state%":"IA","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Cedar Rapids, IA, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"41.9778795","%_wpgmp_metabox_longitude%":"-91.6656232","%rank_math_internal_links_processed%":"1"}},"id":2643,"infowindow_disable":false},{"source":"post","title":"Senior Electrical Project Manager","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Senior Electrical Project Manager\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Our client&nbsp;is currently seeking a Senior Project Manager for an immediate opening in South Bend, IN. The Senior Project Manager&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/senior-electrical-project-manager\/\" name=\"Senior Electrical Project Manager\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Our client&nbsp;is currently seeking a Senior Project Manager for an immediate opening in South Bend, IN. The Senior Project Manager&hellip;","address":"South Bend, IN, USA","location":{"lat":"41.6763545","city":"South Bend","state":"IN","country":"United States","lng":"-86.2519898","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/senior-electrical-project-manager\/","zoom":19,"extra_fields":{"post_excerpt":"Our client&nbsp;is currently seeking a Senior Project Manager for an immediate opening in South Bend, IN. The Senior Project Manager&hellip;","post_content":"<p>Our client&nbsp;is currently seeking a Senior Project Manager for an immediate opening in South Bend, IN. The Senior Project Manager will be responsible for providing overall on-site administrative and technical management on mission critical construction projects for our electrical division.&nbsp;<\/p>\n<p>Responsibilities include but are not limited to:<\/p>\n<ul><li>Supervising total construction effort to ensure project is constructed in accordance with design, budget, and schedule (includes interfacing with customer representatives, A-E representatives, other contractors, etc.)<\/li><li>Planning, coordinating, and supervising on-site functions (scheduling, engineering, material control, and may provide day-to-day direction of on-site administrative staff in accounting, purchasing, etc.)<\/li><li>Supervising craft employees and\/or other contractors as required by the contract<\/li><li>Providing technical assistance, e.g. interpretation of drawings, recommending construction methods and equipment, etc., as required<\/li><li>Initiating and providing extra work estimating and issuance of change orders<\/li><li>Assuming responsibility for productivity of crafts, efficient use of materials and equipment, and contractual performance of the project<\/li><li>Fostering and maintaining good morale and positive relationships with customers, field and\/or office personnel<\/li><li>Participating as a team in calling on and selling customers on potential project<\/li><li>Performing additional assignments per management\u2019s direction<\/li><\/ul>\n<p>Qualifications:<\/p>\n<ul><li>Bachelor\u2019s Degree in Business, Finance, Construction Management, or related industry<\/li><li>10+ years of related experience<\/li><li>Equivalent combination of education\/experience<\/li><\/ul>\n<p>Candidates must possess strong attention to detail, focus on accuracy, solid communication skills, a strong mechanical aptitude, positive initiative and judgement, the ability to problem solve and meet deadlines and the ability to multitask with tact and consideration.<\/p>","post_title":"Senior Electrical Project Manager","post_link":"https:\/\/turnerstaffing.com\/position\/senior-electrical-project-manager\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Senior","%location_country%":"United States","%location_city%":"South Bend","%location_state_id%":"IN","%location_state_name%":"Indiana","%location_city_state%":"South Bend, IN","%education%":"Bachelor's Degree","%department%":"","%description%":"<p>Our client&nbsp;is currently seeking a Senior Project Manager for an immediate opening in South Bend, IN. The Senior Project Manager will be responsible for providing overall on-site administrative and technical management on mission critical construction projects for our electrical division.&nbsp;<\/p>\n<p>Responsibilities include but are not limited to:<\/p>\n<ul><li>Supervising total construction effort to ensure project is constructed in accordance with design, budget, and schedule (includes interfacing with customer representatives, A-E representatives, other contractors, etc.)<\/li><li>Planning, coordinating, and supervising on-site functions (scheduling, engineering, material control, and may provide day-to-day direction of on-site administrative staff in accounting, purchasing, etc.)<\/li><li>Supervising craft employees and\/or other contractors as required by the contract<\/li><li>Providing technical assistance, e.g. interpretation of drawings, recommending construction methods and equipment, etc., as required<\/li><li>Initiating and providing extra work estimating and issuance of change orders<\/li><li>Assuming responsibility for productivity of crafts, efficient use of materials and equipment, and contractual performance of the project<\/li><li>Fostering and maintaining good morale and positive relationships with customers, field and\/or office personnel<\/li><li>Participating as a team in calling on and selling customers on potential project<\/li><li>Performing additional assignments per management\u2019s direction<\/li><\/ul>\n<p>Qualifications:<\/p>\n<ul><li>Bachelor\u2019s Degree in Business, Finance, Construction Management, or related industry<\/li><li>10+ years of related experience<\/li><li>Equivalent combination of education\/experience<\/li><\/ul>\n<p>Candidates must possess strong attention to detail, focus on accuracy, solid communication skills, a strong mechanical aptitude, positive initiative and judgement, the ability to problem solve and meet deadlines and the ability to multitask with tact and consideration.<\/p>","%category%":"Management","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/b1767dd077a4-senior-electrical-project-manager","%breezy_id%":"b1767dd077a4","%breezy_friendly_id%":"b1767dd077a4-senior-electrical-project-manager","%breezy_created_date%":"2025-02-06T21:42:28.664Z","%breezy_updated_date%":"2025-07-31T13:12:05.021Z","%_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":2642,"infowindow_disable":false},{"source":"post","title":"Industrial Estimator","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Industrial Estimator\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Our client is currently seeking an Industrial Estimator for an immediate opening, in Davenport IA. The Industrial Estimator will be&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/industrial-estimator\/\" name=\"Industrial Estimator\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Our client is currently seeking an Industrial Estimator for an immediate opening, in Davenport IA. The Industrial Estimator will be&hellip;","address":"Davenport, IA, USA","location":{"lat":"41.5237912","city":"Davenport","state":"IA","country":"United States","lng":"-90.576587","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/industrial-estimator\/","zoom":19,"extra_fields":{"post_excerpt":"Our client is currently seeking an Industrial Estimator for an immediate opening, in Davenport IA. The Industrial Estimator will be&hellip;","post_content":"<p>Our client is currently seeking an Industrial Estimator for an immediate opening, in Davenport IA. The Industrial Estimator will be responsible for preparing detailed estimates for Industrial projects.<\/p>\n<p>Responsibilities include but are not limited to:<\/p>\n<p>o\tAttending pre-bid meetings to determine scope of work and required contents of projects<\/p>\n<p>o\tReviewing proposed specifications and drawings to determine scope of work and required contents of estimate; gathering quotes, printing drawings, counting, take-off estimating, and respond to RFIs and RFQs<\/p>\n<p>o\tProfessionally interacting with customers, other trades, general contractors, and internal staff<\/p>\n<p>o\tProviding Construction Services with up-to-date CAD drawings; assisting with the assembly of shop drawings as per project requirements<\/p>\n<p>o\tProviding technical assistance, i.e. interpretation of drawings, recommending construction methods and equipment, etc., as required<\/p>\n<p>o\tCommunicate with Project managers regarding bringing in other divisions, project closeout, following awarded contracts as assigned, and manage estimating extra work items, change orders and credits<\/p>\n<p>o\tQualified candidates will have experience in Estimating, cost control, and\/or engineering<\/p>\n<p>o\tTravel as needed<\/p>\n<p>Qualifications:<\/p>\n<p>o\tBachelors in construction, Electrical Engineering or Construction Management or completion of a five year electrical apprenticeship program<\/p>\n<p>o\tMinimum of 5 Years experience in Estimating, Cost-Control and\/or Engineering<\/p>\n<p>o\tCandidates must possess strong attention to detail, focus on accuracy, solid communication skills, positive initiative and judgement, the ability to problem solve and meet deadlines and the ability to multitask with tact and consideration.<\/p>","post_title":"Industrial Estimator","post_link":"https:\/\/turnerstaffing.com\/position\/industrial-estimator\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"","%location_country%":"United States","%location_city%":"Davenport","%location_state_id%":"IA","%location_state_name%":"Iowa","%location_city_state%":"Davenport, IA","%education%":"","%department%":"","%description%":"<p>Our client is currently seeking an Industrial Estimator for an immediate opening, in Davenport IA. The Industrial Estimator will be responsible for preparing detailed estimates for Industrial projects.<\/p>\n<p>Responsibilities include but are not limited to:<\/p>\n<p>o\tAttending pre-bid meetings to determine scope of work and required contents of projects<\/p>\n<p>o\tReviewing proposed specifications and drawings to determine scope of work and required contents of estimate; gathering quotes, printing drawings, counting, take-off estimating, and respond to RFIs and RFQs<\/p>\n<p>o\tProfessionally interacting with customers, other trades, general contractors, and internal staff<\/p>\n<p>o\tProviding Construction Services with up-to-date CAD drawings; assisting with the assembly of shop drawings as per project requirements<\/p>\n<p>o\tProviding technical assistance, i.e. interpretation of drawings, recommending construction methods and equipment, etc., as required<\/p>\n<p>o\tCommunicate with Project managers regarding bringing in other divisions, project closeout, following awarded contracts as assigned, and manage estimating extra work items, change orders and credits<\/p>\n<p>o\tQualified candidates will have experience in Estimating, cost control, and\/or engineering<\/p>\n<p>o\tTravel as needed<\/p>\n<p>Qualifications:<\/p>\n<p>o\tBachelors in construction, Electrical Engineering or Construction Management or completion of a five year electrical apprenticeship program<\/p>\n<p>o\tMinimum of 5 Years experience in Estimating, Cost-Control and\/or Engineering<\/p>\n<p>o\tCandidates must possess strong attention to detail, focus on accuracy, solid communication skills, positive initiative and judgement, the ability to problem solve and meet deadlines and the ability to multitask with tact and consideration.<\/p>","%category%":"","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/21170fe26666-industrial-estimator","%breezy_id%":"21170fe26666","%breezy_friendly_id%":"21170fe26666-industrial-estimator","%breezy_created_date%":"2024-10-21T17:23:40.095Z","%breezy_updated_date%":"2025-07-31T13:13:24.516Z","%_wpgmp_location_city%":"Davenport","%_wpgmp_location_state%":"IA","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Davenport, IA, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"41.5237912","%_wpgmp_metabox_longitude%":"-90.576587","%rank_math_internal_links_processed%":"1"}},"id":2641,"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; 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\/project-manager-mining\/\" name=\"Project Manager &#8211; Mining\" 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":"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-manager-mining\/","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><li>Familiarity with the frac sand market and the hydraulic fracturing process and the data sources and standards associated with them<\/li><\/ul>\n<p><strong>Benefits:<\/strong><\/p>\n<p>Turner Mining Group offers a competitive salary, 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.<\/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\/","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%":"Some High School Coursework","%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><li>Familiarity with the frac sand market and the hydraulic fracturing process and the data sources and standards associated with them<\/li><\/ul>\n<p><strong>Benefits:<\/strong><\/p>\n<p>Turner Mining Group offers a competitive salary, 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.<\/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\/e50e253f80cb-project-manager-mining","%breezy_id%":"e50e253f80cb","%breezy_friendly_id%":"e50e253f80cb-project-manager-mining","%breezy_created_date%":"2025-07-29T16:25:37.374Z","%breezy_updated_date%":"2025-07-29T16:32:59.218Z","%_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":2639,"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; 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\/project-manager-mining-2\/\" name=\"Project Manager &#8211; Mining\" 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\/project-manager-mining-2\/","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, 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.<\/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-2\/","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><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, 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.<\/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\/8960864f773c-project-manager-mining","%breezy_id%":"8960864f773c","%breezy_friendly_id%":"8960864f773c-project-manager-mining","%breezy_created_date%":"2025-07-29T16:31:29.459Z","%breezy_updated_date%":"2025-07-29T16:32:25.112Z","%_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":2640,"infowindow_disable":false},{"source":"post","title":"Security Technician","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Security Technician\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Our client is currently recruiting Security Technicians for immediate openings in the Des Moines, Davenport, Iowa City, and Cedar Rapids,&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/security-technician\/\" name=\"Security Technician\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Our client is currently recruiting Security Technicians for immediate openings in the Des Moines, Davenport, Iowa City, and Cedar Rapids,&hellip;","address":"Davenport, IA, USA","location":{"lat":"41.5237912","city":"Davenport","state":"IA","country":"United States","lng":"-90.576587","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/security-technician\/","zoom":19,"extra_fields":{"post_excerpt":"Our client is currently recruiting Security Technicians for immediate openings in the Des Moines, Davenport, Iowa City, and Cedar Rapids,&hellip;","post_content":"<p>Our client is currently recruiting Security Technicians for immediate openings in the Des Moines, Davenport, Iowa City, and Cedar Rapids, IA areas.<\/p>\n<p>Main duties include programing &amp; installation of security systems on large construction, new construction, and remodeling projects.<\/p>\n<p>Qualified candidates will have formal training in security and low voltage installation, reliable transportation, and the ability to follow directions, climb ladders and lift up to 50lbs repetitively. Security systems, VMS software, low voltage knowledge and understanding and experience pulling and routing wires is required.<\/p>\n<p>Qualified candidates should submit a summary of qualifications, security system and VMS software experience as well as a resume.<\/p>","post_title":"Security Technician","post_link":"https:\/\/turnerstaffing.com\/position\/security-technician\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Mid Level","%location_country%":"United States","%location_city%":"Davenport","%location_state_id%":"IA","%location_state_name%":"Iowa","%location_city_state%":"Davenport, IA","%education%":"Unspecified","%department%":"","%description%":"<p>Our client is currently recruiting Security Technicians for immediate openings in the Des Moines, Davenport, Iowa City, and Cedar Rapids, IA areas.<\/p>\n<p>Main duties include programing &amp; installation of security systems on large construction, new construction, and remodeling projects.<\/p>\n<p>Qualified candidates will have formal training in security and low voltage installation, reliable transportation, and the ability to follow directions, climb ladders and lift up to 50lbs repetitively. Security systems, VMS software, low voltage knowledge and understanding and experience pulling and routing wires is required.<\/p>\n<p>Qualified candidates should submit a summary of qualifications, security system and VMS software experience as well as a resume.<\/p>","%category%":"Operations","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/b1a4c983e408-security-technician","%breezy_id%":"b1a4c983e408","%breezy_friendly_id%":"b1a4c983e408-security-technician","%breezy_created_date%":"2024-10-14T15:32:15.462Z","%breezy_updated_date%":"2025-07-31T13:13:36.296Z","%_wpgmp_location_city%":"Davenport","%_wpgmp_location_state%":"IA","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Davenport, IA, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"41.5237912","%_wpgmp_metabox_longitude%":"-90.576587","%rank_math_internal_links_processed%":"1"}},"id":2638,"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-07-28T18:09:39.244Z","%_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":"Industrial Estimator- Surface and Underground","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Industrial Estimator- Surface and Underground\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Job Duties and Responsibilities: \u2022 Evaluate new bid opportunities for constructability and internal suitability. \u2022 Summarize and present high-level scoping&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/industrial-estimator-surface-and-underground\/\" name=\"Industrial Estimator- Surface and Underground\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Job Duties and Responsibilities: \u2022 Evaluate new bid opportunities for constructability and internal suitability. \u2022 Summarize and present high-level scoping&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\/industrial-estimator-surface-and-underground\/","zoom":19,"extra_fields":{"post_excerpt":"Job Duties and Responsibilities: \u2022 Evaluate new bid opportunities for constructability and internal suitability. \u2022 Summarize and present high-level scoping&hellip;","post_content":"<p>Job Duties and Responsibilities:<\/p>\n<p>\u2022 Evaluate new bid opportunities for constructability and internal suitability.<\/p>\n<p>\u2022 Summarize and present high-level scoping of potential projects to internal stakeholders for go\/ no go<\/p>\n<p>approval.<\/p>\n<p>\u2022 Visit project work sites, participate in pre-bid meetings, clarify scope of work, and prepare RFI's.<\/p>\n<p>\u2022 Accurately utilize project plans and specifications to identify scopes of work, assign crews, schedules,<\/p>\n<p>materials, and subcontracting opportunities<\/p>\n<p>\u2022 Interpret drawings and plans to create detailed material takeoffs.<\/p>\n<p>\u2022 Create detailed cost estimates using HCSS Heavy Bid estimating software, and or internal worksheets, to<\/p>\n<p>produce detailed estimates that follow the pricing format required by the client.<\/p>\n<p>\u2022 Research pricing for estimates based on historical and regional costs.<\/p>\n<p>\u2022 Develop self-performed estimates for trades that our client chooses to self-perform.<\/p>\n<p>\u2022 Understand and seek out specialty subcontractors and suppliers that will assist in the fulfillment of the<\/p>\n<p>requirements of the project.<\/p>\n<p>\u2022 Work closely with subcontractors, suppliers, and other stakeholders through the bid process to<\/p>\n<p>understand and capture the complete scope of each trade involved in the project and the overall estimate.<\/p>\n<p>\u2022 Obtain current material and equipment quotes used in the development of an estimate.<\/p>\n<p>\u2022 Work closely with other estimators and business unit leaders to develop strategy, competitive<\/p>\n<p>differentiation, and an overall understanding of the project.<\/p>\n<p>\u2022 Coordinate and lead estimate reviews with business unit leaders and or other estimators to finalize<\/p>\n<p>estimates in HCSS.<\/p>\n<p>\u2022 Develop and\/or manage the development of preliminary bid schedules based on the information provided<\/p>\n<p>in the RFP, utilizing MS Project software.<\/p>\n<p>\u2022 Understand and manage our client\u2019s risk as part of the proposal preparation process.<\/p>\n<p>\u2022 Prepare and submit written technical proposals, and fill out all other bid documents, accurately<\/p>\n<p>addressing the project owners\u2019 requests for proposals by the bid submission deadline.<\/p>\n<p>Minimum Requirements:<\/p>\n<p>\u2022 Field experience, or education in Civil, Mechanical, Structural Engineering, or Project\/Construction<\/p>\n<p>management preferred.<\/p>\n<p>\u2022 3-5 years of experience in heavy industrial, or commercial estimating required.<\/p>\n<p>\u2022 General knowledge and understanding of new construction, and process maintenance and repair work<\/p>\n<p>relating to surface and underground mine sites.<\/p>\n<p>\u2022 Experience delivering lump sum, design build, and time and materials estimates for projects<\/p>\n<p>encompassing; civil, structural foundations, structural steel erection, piping, mechanical installations,<\/p>\n<p>and other industrial applications preferred.<\/p>\n<p>\u2022 HCSS (Heavy Bid Software), MS Project, and Excel strongly preferred.<\/p>\n<p>\u2022 Experience identifying and presenting alternative delivery methods, or value engineering preferred.<\/p>\n<p>\u2022 Strong prioritization and organizational skills<\/p>\n<p>\u2022 Flexibility, sense of urgency, and the ability to multi-task.<\/p>\n<p>\u2022 Highly productive and willing to manage a busy work schedule independently.<\/p>\n<p>\u2022 Strong verbal and written (technical) communication and presentation skills.<\/p>\n<p>Work Environment:<\/p>\n<p>\u2022 Work may require occasional weekend and\/or evening work.<\/p>\n<p>\u2022 Regular office environment expectations.<\/p>\n<p>o Sitting at least 80%<\/p>\n<p>o Standing, walking and bending at least 10%<\/p>\n<p>\u2022 Infrequent travel to job sites may be required. In those circumstances there are the following industrial<\/p>\n<p>environment expectations:<\/p>\n<p>o The environment may include minimal exposure to hazards typical of an industrial job site<\/p>\n<p>o Personal protective equipment is required when on job sites, including hard hats, hearing<\/p>\n<p>protection, safety glasses, safety footwear, and \u2013 as needed- respirators, gloves, and other<\/p>\n<p>required protective equipment as needed.<\/p>","post_title":"Industrial Estimator- Surface and Underground","post_link":"https:\/\/turnerstaffing.com\/position\/industrial-estimator-surface-and-underground\/","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>Job Duties and Responsibilities:<\/p>\n<p>\u2022 Evaluate new bid opportunities for constructability and internal suitability.<\/p>\n<p>\u2022 Summarize and present high-level scoping of potential projects to internal stakeholders for go\/ no go<\/p>\n<p>approval.<\/p>\n<p>\u2022 Visit project work sites, participate in pre-bid meetings, clarify scope of work, and prepare RFI's.<\/p>\n<p>\u2022 Accurately utilize project plans and specifications to identify scopes of work, assign crews, schedules,<\/p>\n<p>materials, and subcontracting opportunities<\/p>\n<p>\u2022 Interpret drawings and plans to create detailed material takeoffs.<\/p>\n<p>\u2022 Create detailed cost estimates using HCSS Heavy Bid estimating software, and or internal worksheets, to<\/p>\n<p>produce detailed estimates that follow the pricing format required by the client.<\/p>\n<p>\u2022 Research pricing for estimates based on historical and regional costs.<\/p>\n<p>\u2022 Develop self-performed estimates for trades that our client chooses to self-perform.<\/p>\n<p>\u2022 Understand and seek out specialty subcontractors and suppliers that will assist in the fulfillment of the<\/p>\n<p>requirements of the project.<\/p>\n<p>\u2022 Work closely with subcontractors, suppliers, and other stakeholders through the bid process to<\/p>\n<p>understand and capture the complete scope of each trade involved in the project and the overall estimate.<\/p>\n<p>\u2022 Obtain current material and equipment quotes used in the development of an estimate.<\/p>\n<p>\u2022 Work closely with other estimators and business unit leaders to develop strategy, competitive<\/p>\n<p>differentiation, and an overall understanding of the project.<\/p>\n<p>\u2022 Coordinate and lead estimate reviews with business unit leaders and or other estimators to finalize<\/p>\n<p>estimates in HCSS.<\/p>\n<p>\u2022 Develop and\/or manage the development of preliminary bid schedules based on the information provided<\/p>\n<p>in the RFP, utilizing MS Project software.<\/p>\n<p>\u2022 Understand and manage our client\u2019s risk as part of the proposal preparation process.<\/p>\n<p>\u2022 Prepare and submit written technical proposals, and fill out all other bid documents, accurately<\/p>\n<p>addressing the project owners\u2019 requests for proposals by the bid submission deadline.<\/p>\n<p>Minimum Requirements:<\/p>\n<p>\u2022 Field experience, or education in Civil, Mechanical, Structural Engineering, or Project\/Construction<\/p>\n<p>management preferred.<\/p>\n<p>\u2022 3-5 years of experience in heavy industrial, or commercial estimating required.<\/p>\n<p>\u2022 General knowledge and understanding of new construction, and process maintenance and repair work<\/p>\n<p>relating to surface and underground mine sites.<\/p>\n<p>\u2022 Experience delivering lump sum, design build, and time and materials estimates for projects<\/p>\n<p>encompassing; civil, structural foundations, structural steel erection, piping, mechanical installations,<\/p>\n<p>and other industrial applications preferred.<\/p>\n<p>\u2022 HCSS (Heavy Bid Software), MS Project, and Excel strongly preferred.<\/p>\n<p>\u2022 Experience identifying and presenting alternative delivery methods, or value engineering preferred.<\/p>\n<p>\u2022 Strong prioritization and organizational skills<\/p>\n<p>\u2022 Flexibility, sense of urgency, and the ability to multi-task.<\/p>\n<p>\u2022 Highly productive and willing to manage a busy work schedule independently.<\/p>\n<p>\u2022 Strong verbal and written (technical) communication and presentation skills.<\/p>\n<p>Work Environment:<\/p>\n<p>\u2022 Work may require occasional weekend and\/or evening work.<\/p>\n<p>\u2022 Regular office environment expectations.<\/p>\n<p>o Sitting at least 80%<\/p>\n<p>o Standing, walking and bending at least 10%<\/p>\n<p>\u2022 Infrequent travel to job sites may be required. In those circumstances there are the following industrial<\/p>\n<p>environment expectations:<\/p>\n<p>o The environment may include minimal exposure to hazards typical of an industrial job site<\/p>\n<p>o Personal protective equipment is required when on job sites, including hard hats, hearing<\/p>\n<p>protection, safety glasses, safety footwear, and \u2013 as needed- respirators, gloves, and other<\/p>\n<p>required protective equipment as needed.<\/p>","%category%":"Operations","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/3dfc3f0871a3-industrial-estimator-surface-and-underground","%breezy_id%":"3dfc3f0871a3","%breezy_friendly_id%":"3dfc3f0871a3-industrial-estimator-surface-and-underground","%breezy_created_date%":"2025-07-28T16:30:10.961Z","%breezy_updated_date%":"2025-07-28T16:32:01.945Z","%_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":2636,"infowindow_disable":false},{"source":"post","title":"Heavy Equipment Operator","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Heavy Equipment Operator\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Turner Staffing Group \u2013 Heavy Equipment Operator Do you love the construction world? Do you think differently? Are you ready&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/heavy-equipment-operator-10\/\" name=\"Heavy Equipment 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 the construction world? Do you think differently? Are you ready&hellip;","address":"Clarksville, TN, USA","location":{"lat":"36.5297706","city":"Clarksville","state":"TN","country":"United States","lng":"-87.3611694","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/heavy-equipment-operator-10\/","zoom":19,"extra_fields":{"post_excerpt":"Turner Staffing Group \u2013 Heavy Equipment Operator Do you love the construction world? Do you think differently? Are you ready&hellip;","post_content":"<p><strong><u>Turner Staffing Group \u2013 Heavy Equipment Operator<\/u><\/strong><\/p>\n<p>Do you love the construction 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 Heavy Equipment Operators for our fast-growing, forward thinking client based in the Clarksville, TN 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 heavy equipment 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":"Heavy Equipment Operator","post_link":"https:\/\/turnerstaffing.com\/position\/heavy-equipment-operator-10\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Mid Level","%location_country%":"United States","%location_city%":"Clarksville","%location_state_id%":"TN","%location_state_name%":"Tennessee","%location_city_state%":"Clarksville, TN","%education%":"Unspecified","%department%":"","%description%":"<p><strong><u>Turner Staffing Group \u2013 Heavy Equipment Operator<\/u><\/strong><\/p>\n<p>Do you love the construction 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 Heavy Equipment Operators for our fast-growing, forward thinking client based in the Clarksville, TN 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 heavy equipment 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\/d992bc8f9e27-heavy-equipment-operator","%breezy_id%":"d992bc8f9e27","%breezy_friendly_id%":"d992bc8f9e27-heavy-equipment-operator","%breezy_created_date%":"2025-04-04T13:44:22.861Z","%breezy_updated_date%":"2025-07-29T15:51:09.496Z","%_wpgmp_location_city%":"Clarksville","%_wpgmp_location_state%":"TN","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Clarksville, TN, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"36.5297706","%_wpgmp_metabox_longitude%":"-87.3611694","%rank_math_internal_links_processed%":"1"}},"id":2620,"infowindow_disable":false},{"source":"post","title":"Haul Truck Driver","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Haul Truck Driver\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Turner Mining Group \u2013 Haul Truck Driver Do you love mining? Do you think differently? Are you ready to define&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/haul-truck-driver\/\" name=\"Haul Truck Driver\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Turner Mining Group \u2013 Haul Truck Driver Do you love mining? Do you think differently? Are you ready to define&hellip;","address":"Kingman, AZ, USA","location":{"lat":"35.1912977","city":"Kingman","state":"AZ","country":"United States","lng":"-114.0522845","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/haul-truck-driver\/","zoom":19,"extra_fields":{"post_excerpt":"Turner Mining Group \u2013 Haul Truck Driver Do you love mining? Do you think differently? Are you ready to define&hellip;","post_content":"<p style=\"color:#555555\"><strong><span style=\"text-decoration:underline\"><span style=\"color:#555555\">Turner Mining Group \u2013 Haul Truck Driver<\/span><\/span><\/strong><\/p>\n<p style=\"color:#000000\"><span style=\"color:#333333\">Do you love mining? Do you think differently? Are you ready to define the future of this industry?<\/span><\/p>\n<p style=\"color:#000000\"><span style=\"color:#333333\">We\u2019ve been waiting for you! Turner Mining Group is committed to changing the way mining companies do business. We develop our people. We partner with our clients. We believe in win, win, win.<\/span><\/p>\n<p style=\"color:#000000\"><span style=\"color:#333333\">We are looking for a dynamic and talented mining Haul Truck Drivers for our fast-growing, forward thinking mining services company headquartered in Bloomington, Indiana with our Operations team headquartered in Salt Lake City, Utah.<\/span><\/p>\n<p style=\"color:#000000\"><span style=\"color:#333333\">Turner Mining Group is seeking an energetic mining professionals who can leverage their mining knowledge to expand upon our fast-growing business, creating best practices for equipment operations to ensure profitable operations.<\/span><\/p>\n<p style=\"color:#000000\"><span style=\"color:#555555\">If you would like to get involved and make a large contribution in mining or minerals processing, then you may enjoy a position as Haul Truck Driver. This position is great for anyone who would like to begin a career in mining, has experience in a related industry but would like to learn about mining, or has experience as a miner but would like to grow into further positions with Turner Mining Group.<\/span><\/p>\n<p style=\"color:#000000\"><strong><span style=\"color:#333333\">You<\/span><\/strong><\/p>\n<p style=\"color:#000000\"><span style=\"color:#333333\">You want to work for a services company that is rapidly changing the way the largest materials producers do business. You are motivated by solving problems and partnering with our clients and suppliers. You want to work with great people and enjoy being a part of a strong team. You are a knowledgeable Operator who is not afraid to jump into every detail. You want to be in a place where continuous learning and growth is the norm. You are adaptable and able to juggle multiple initiatives concurrently.<\/span><\/p>\n<p style=\"color:#000000\"><strong><span style=\"color:#555555\">Responsibilities:<\/span><\/strong><\/p>\n<ul><li><span style=\"color:#555555\">Operate and drive heavy haul trucks to transport tons of materials over short distances in a surface environment.<\/span><\/li><li><span style=\"color:#555555\">Perform inspections of vehicle systems, equipment and accessories such as tires, lights, turn signals and brakes<\/span><\/li><li><span style=\"color:#555555\">Ensure cargo is properly loaded according to safety requirements<\/span><\/li><li><span style=\"color:#555555\">Follow all safety policies, procedures and legislation<\/span><\/li><li><span style=\"color:#555555\">Maintain paper or electronic log book<\/span><\/li><li><span style=\"color:#555555\">Communicate with Dispatcher and other Haul Truck Drivers using communication devices such as a two-ways radio or onboard computers<\/span><\/li><li><span style=\"color:#555555\">May drive special purpose vehicles, including: end dump trucks, center dump truck units and water trucks<\/span><\/li><\/ul>\n<p style=\"color:#000000\"><strong><span style=\"color:#333333\">Requirements:<\/span><\/strong><\/p>\n<ul><li><span style=\"color:#555555\">Safety oriented, awareness of everyone and everything that is around you<\/span><\/li><li><span style=\"color:#555555\">Strong work ethic<\/span><\/li><li><span style=\"color:#555555\">Willingness to learn<\/span><\/li><li><span style=\"color:#555555\">Ability to be flexible and to adapt<\/span><\/li><li><span style=\"color:#555555\">Experience with heavy equipment<\/span><\/li><li><span style=\"color:#555555\">Preferred to have MSHA training<\/span><\/li><\/ul>\n<p style=\"color:#000000\"><strong><span style=\"color:#333333\">Benefits:<\/span><\/strong><\/p>\n<p style=\"color:#000000\"><span style=\"color:#333333\">Turner Mining Group offers a competitive salary, an excellent work culture, career advancement opportunities. Our team offers a benefits program which includes Medical, Dental, Vision, Life, and a 401k with company match.<\/span><\/p>\n<p style=\"color:#000000\"><span style=\"color:#333333\">At Turner Mining Group, we encourage and celebrate an inclusive environment for all employees and are proud to be an equal opportunity workplace and affirmative action employer.<\/span><\/p>\n<p style=\"color:#000000\">&nbsp;<\/p>\n<p style=\"color:#000000\">&nbsp;<\/p>\n<p style=\"color:#555555\"><br><\/p>\n<p style=\"color:#000000\"><span style=\"color:#333333\"><\/span><br><\/p>","post_title":"Haul Truck Driver","post_link":"https:\/\/turnerstaffing.com\/position\/haul-truck-driver\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"","%location_country%":"United States","%location_city%":"Kingman","%location_state_id%":"AZ","%location_state_name%":"Arizona","%location_city_state%":"Kingman, AZ","%education%":"","%department%":"Construction","%description%":"<p style=\"color:#555555;\"><strong><span style=\"text-decoration:underline;\"><span style=\"color:#555555;\">Turner Mining Group \u2013 Haul Truck Driver<\/span><\/span><\/strong><\/p>\n<p style=\"color:#000000;\"><span style=\"color:#333333;\">Do you love mining? Do you think differently? Are you ready to define the future of this industry?<\/span><\/p>\n<p style=\"color:#000000;\"><span style=\"color:#333333;\">We\u2019ve been waiting for you! Turner Mining Group is committed to changing the way mining companies do business. We develop our people. We partner with our clients. We believe in win, win, win.<\/span><\/p>\n<p style=\"color:#000000;\"><span style=\"color:#333333;\">We are looking for a dynamic and talented mining Haul Truck Drivers for our fast-growing, forward thinking mining services company headquartered in Bloomington, Indiana with our Operations team headquartered in Salt Lake City, Utah.<\/span><\/p>\n<p style=\"color:#000000;\"><span style=\"color:#333333;\">Turner Mining Group is seeking an energetic mining professionals who can leverage their mining knowledge to expand upon our fast-growing business, creating best practices for equipment operations to ensure profitable operations.<\/span><\/p>\n<p style=\"color:#000000;\"><span style=\"color:#555555;\">If you would like to get involved and make a large contribution in mining or minerals processing, then you may enjoy a position as Haul Truck Driver. This position is great for anyone who would like to begin a career in mining, has experience in a related industry but would like to learn about mining, or has experience as a miner but would like to grow into further positions with Turner Mining Group.<\/span><\/p>\n<p style=\"color:#000000;\"><strong><span style=\"color:#333333;\">You<\/span><\/strong><\/p>\n<p style=\"color:#000000;\"><span style=\"color:#333333;\">You want to work for a services company that is rapidly changing the way the largest materials producers do business. You are motivated by solving problems and partnering with our clients and suppliers. You want to work with great people and enjoy being a part of a strong team. You are a knowledgeable Operator who is not afraid to jump into every detail. You want to be in a place where continuous learning and growth is the norm. You are adaptable and able to juggle multiple initiatives concurrently.<\/span><\/p>\n<p style=\"color:#000000;\"><strong><span style=\"color:#555555;\">Responsibilities:<\/span><\/strong><\/p>\n<ul><li><span style=\"color:#555555;\">Operate and drive heavy haul trucks to transport tons of materials over short distances in a surface environment.<\/span><\/li><li><span style=\"color:#555555;\">Perform inspections of vehicle systems, equipment and accessories such as tires, lights, turn signals and brakes<\/span><\/li><li><span style=\"color:#555555;\">Ensure cargo is properly loaded according to safety requirements<\/span><\/li><li><span style=\"color:#555555;\">Follow all safety policies, procedures and legislation<\/span><\/li><li><span style=\"color:#555555;\">Maintain paper or electronic log book<\/span><\/li><li><span style=\"color:#555555;\">Communicate with Dispatcher and other Haul Truck Drivers using communication devices such as a two-ways radio or onboard computers<\/span><\/li><li><span style=\"color:#555555;\">May drive special purpose vehicles, including: end dump trucks, center dump truck units and water trucks<\/span><\/li><\/ul>\n<p style=\"color:#000000;\"><strong><span style=\"color:#333333;\">Requirements:<\/span><\/strong><\/p>\n<ul><li><span style=\"color:#555555;\">Safety oriented, awareness of everyone and everything that is around you<\/span><\/li><li><span style=\"color:#555555;\">Strong work ethic<\/span><\/li><li><span style=\"color:#555555;\">Willingness to learn<\/span><\/li><li><span style=\"color:#555555;\">Ability to be flexible and to adapt<\/span><\/li><li><span style=\"color:#555555;\">Experience with heavy equipment<\/span><\/li><li><span style=\"color:#555555;\">Preferred to have MSHA training<\/span><\/li><\/ul>\n<p style=\"color:#000000;\"><strong><span style=\"color:#333333;\">Benefits:<\/span><\/strong><\/p>\n<p style=\"color:#000000;\"><span style=\"color:#333333;\">Turner Mining Group offers a competitive salary, an excellent work culture, career advancement opportunities. Our team offers a benefits program which includes Medical, Dental, Vision, Life, and a 401k with company match.<\/span><\/p>\n<p style=\"color:#000000;\"><span style=\"color:#333333;\">At Turner Mining Group, we encourage and celebrate an inclusive environment for all employees and are proud to be an equal opportunity workplace and affirmative action employer.<\/span><\/p>\n<p style=\"color:#000000;\">&nbsp;<\/p>\n<p style=\"color:#000000;\">&nbsp;<\/p>\n<p style=\"color:#555555;\"><br><\/p>\n<p style=\"color:#000000;\"><span style=\"color:#333333;\"><\/span><br><\/p>","%category%":"Operations","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/47d9f8dffb11-haul-truck-driver","%breezy_id%":"47d9f8dffb11","%breezy_friendly_id%":"47d9f8dffb11-haul-truck-driver","%breezy_created_date%":"2021-11-16T20:55:19.000Z","%breezy_updated_date%":"2025-07-21T17:04:27.887Z","%_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":2616,"infowindow_disable":false},{"source":"post","title":"Haul Truck Driver &#8211; Mining","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Haul Truck Driver &#8211; Mining\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Turner Mining Group \u2013 Haul Truck Driver We are looking for a dynamic and talented mining Haul Truck Drivers for&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/haul-truck-driver-mining\/\" name=\"Haul Truck Driver &#8211; Mining\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Turner Mining Group \u2013 Haul Truck Driver We are looking for a dynamic and talented mining Haul Truck Drivers 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\/haul-truck-driver-mining\/","zoom":19,"extra_fields":{"post_excerpt":"Turner Mining Group \u2013 Haul Truck Driver We are looking for a dynamic and talented mining Haul Truck Drivers for&hellip;","post_content":"<p><strong><u>Turner Mining Group \u2013 Haul Truck Driver<\/u><\/strong><\/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!<\/p>\n<p>Turner Mining Group is seeking an energetic mining professionals who can leverage their mining knowledge to expand upon our fast-growing business, creating best practices for equipment operations to ensure profitable operations.<\/p>\n<p>If you would like to get involved and make a large contribution in mining or minerals processing, then you may enjoy a position as Haul Truck Driver. This position is great for anyone who would like to begin a career in mining, has experience in a related industry but would like to learn about mining, or has experience as a miner but would like to grow into further positions with Turner Mining Group.<\/p>\n<p><strong>You<\/strong><\/p>\n<p>You want to work for a services company that is rapidly changing the way the largest materials producers do business. You are motivated by solving problems and partnering with our clients and suppliers. You want to work with great people and enjoy being a part of a strong team. You are a knowledgeable Operator who is not afraid to jump into every detail. You want to be in a place where continuous learning and growth is the norm. You are adaptable and able to juggle multiple initiatives concurrently.<\/p>\n<p><strong>Responsibilities:<\/strong><\/p>\n<ul><li>Operate and drive heavy haul trucks to transport tons of materials over short distances in a surface environment.<\/li><li>Perform inspections of vehicle systems, equipment and accessories such as tires, lights, turn signals and brakes<\/li><li>Ensure cargo is properly loaded according to safety requirements<\/li><li>Follow all safety policies, procedures and legislation<\/li><li>Maintain paper or electronic logbook<\/li><li>Communicate with Dispatcher and other Haul Truck Drivers using communication devices such as a two-ways radio or onboard computers<\/li><li>May drive special purpose vehicles, including end dump trucks, center dump truck units and water trucks<\/li><\/ul>\n<p><strong>Requirements:<\/strong><\/p>\n<ul><li>Safety oriented, awareness of everyone and everything that is around you<\/li><li>Strong work ethic<\/li><li>Willingness to learn<\/li><li>Ability to be flexible and to adapt<\/li><li>Experience with heavy equipment<\/li><li>Preferred to have MSHA training<\/li><\/ul>\n<p><strong>Benefits:<\/strong><\/p>\n<p>Turner Mining Group offers a competitive salary, an excellent work culture, career advancement opportunities. Our team offers a benefits program which includes Medical, Dental, Vision, Life, and a 401k with company match.<\/p>\n<p>At Turner Mining Group, we encourage and celebrate an inclusive environment for all employees and are proud to be an equal opportunity workplace and affirmative action employer.<\/p>","post_title":"Haul Truck Driver &#8211; Mining","post_link":"https:\/\/turnerstaffing.com\/position\/haul-truck-driver-mining\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Entry Level","%location_country%":"United States","%location_city%":"Kingman","%location_state_id%":"AZ","%location_state_name%":"Arizona","%location_city_state%":"Kingman, AZ","%education%":"Unspecified","%department%":"Equipment Operation","%description%":"<p><strong><u>Turner Mining Group \u2013 Haul Truck Driver<\/u><\/strong><\/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!<\/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\/649c16eff839-haul-truck-driver-mining","%breezy_id%":"649c16eff839","%breezy_friendly_id%":"649c16eff839-haul-truck-driver-mining","%breezy_created_date%":"2025-07-20T15:31:40.684Z","%breezy_updated_date%":"2025-07-20T15:32:28.269Z","%_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":2615,"infowindow_disable":false},{"source":"post","title":"Excavator Operator","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Excavator Operator\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Turner Mining Group \u2013 Heavy Equipment Operator 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\/excavator-operator-3\/\" name=\"Excavator 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\/excavator-operator-3\/","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":"Excavator Operator","post_link":"https:\/\/turnerstaffing.com\/position\/excavator-operator-3\/","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\/439fdc989ff8-excavator-operator","%breezy_id%":"439fdc989ff8","%breezy_friendly_id%":"439fdc989ff8-excavator-operator","%breezy_created_date%":"2025-07-20T15:10:53.517Z","%breezy_updated_date%":"2025-07-20T15:12:35.097Z","%_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":2613,"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-07-20T15:19:26.650Z","%_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-07-17T15:10:02.591Z","%_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":"Site Administrator\/Maintenance Planner","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Site Administrator\/Maintenance Planner\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Job Summary Turner Mining Group is seeking a highly organized Site Administrator\/Mobile Maintenance Planner to support day-to-day maintenance scheduling for&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/site-administrator-mobile-maintenance-planner\/\" name=\"Site Administrator\/Maintenance Planner\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Job Summary Turner Mining Group is seeking a highly organized Site Administrator\/Mobile Maintenance Planner to support day-to-day maintenance scheduling for&hellip;","address":"Midland-Odessa, TX, USA","location":{"lat":"31.9391746","city":"Midland-Odessa","state":"TX","country":"United States","lng":"-102.2522487","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/site-administrator-mobile-maintenance-planner\/","zoom":19,"extra_fields":{"post_excerpt":"Job Summary Turner Mining Group is seeking a highly organized Site Administrator\/Mobile Maintenance Planner to support day-to-day maintenance scheduling for&hellip;","post_content":"<h3><strong>Job Summary<\/strong><\/h3>\n<p>Turner Mining Group is seeking a highly organized <strong>Site Administrator<\/strong>\/<strong>Mobile Maintenance Planner<\/strong> to support day-to-day maintenance scheduling for mobile equipment. This role is responsible for planning and coordinating maintenance activities, tracking work progress, and ensuring that repairs and preventive maintenance are completed safely, efficiently, and on schedule.<\/p>\n<p>The ideal candidate has strong organizational skills, scheduling experience, and a solid understanding of maintenance operations in a mining or heavy equipment environment.<\/p>\n<h3><strong>Key Responsibilities<\/strong><\/h3>\n<ul>\n<li>\n<p>Develop and maintain daily and weekly maintenance schedules for mobile equipment, including trucks, loaders, and other heavy machinery.<\/p>\n<\/li>\n<li>\n<p>Coordinate with maintenance supervisors, vendors, and operations teams to ensure timely completion of scheduled work.<\/p>\n<\/li>\n<li>\n<p>Monitor work progress, update schedules as needed, and communicate any delays or changes.<\/p>\n<\/li>\n<li>\n<p>Track parts orders and availability to ensure all required components are on hand before scheduled work.<\/p>\n<\/li>\n<li>\n<p>Maintain accurate records of maintenance activities and work orders.<\/p>\n<\/li>\n<li>\n<p>Communicate regularly with team members to provide updates on equipment status and upcoming scheduled work.<\/p>\n<\/li>\n<li>\n<p>Ensure all maintenance work follows company safety standards and MSHA regulations.<\/p>\n<\/li>\n<\/ul>\n<h3><strong>Qualifications<\/strong><\/h3>\n<ul>\n<li>\n<p>High school diploma or equivalent required; technical or business coursework preferred.<\/p>\n<\/li>\n<li>\n<p>Previous experience in maintenance planning or scheduling, preferably in mining, construction, or a heavy equipment environment.<\/p>\n<\/li>\n<li>\n<p>Strong understanding of maintenance operations and mobile equipment.<\/p>\n<\/li>\n<li>\n<p>Proficiency in scheduling software and Microsoft Office (Excel required).<\/p>\n<\/li>\n<li>\n<p>Excellent organizational and communication skills.<\/p>\n<\/li>\n<li>\n<p>Valid driver\u2019s license with a clean driving record.<\/p>\n<\/li>\n<\/ul>\n<h3><strong>Physical Requirements<\/strong><\/h3>\n<ul>\n<li>\n<p>Ability to work in both office and field settings.<\/p>\n<\/li>\n<li>\n<p>Comfortable standing or walking for extended periods.<\/p>\n<\/li>\n<li>\n<p>Ability to work in varying weather conditions (heat, cold, dust).<\/p><\/li><li><p>Must pass pre-employment and random drug testing as required<\/p><\/li><\/ul><p><\/p><p><br><strong>Benefits:<br><br><\/strong>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.<br><br>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><p><\/p>","post_title":"Site Administrator\/Maintenance Planner","post_link":"https:\/\/turnerstaffing.com\/position\/site-administrator-mobile-maintenance-planner\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Associate","%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%":"Administrative","%description%":"<h3><strong>Job Summary<\/strong><\/h3>\n<p>Turner Mining Group is seeking a highly organized <strong>Site Administrator<\/strong>\/<strong>Mobile Maintenance Planner<\/strong> to support day-to-day maintenance scheduling for mobile equipment. This role is responsible for planning and coordinating maintenance activities, tracking work progress, and ensuring that repairs and preventive maintenance are completed safely, efficiently, and on schedule.<\/p>\n<p>The ideal candidate has strong organizational skills, scheduling experience, and a solid understanding of maintenance operations in a mining or heavy equipment environment.<\/p>\n<h3><strong>Key Responsibilities<\/strong><\/h3>\n<ul>\n<li>\n<p>Develop and maintain daily and weekly maintenance schedules for mobile equipment, including trucks, loaders, and other heavy machinery.<\/p>\n<\/li>\n<li>\n<p>Coordinate with maintenance supervisors, vendors, and operations teams to ensure timely completion of scheduled work.<\/p>\n<\/li>\n<li>\n<p>Monitor work progress, update schedules as needed, and communicate any delays or changes.<\/p>\n<\/li>\n<li>\n<p>Track parts orders and availability to ensure all required components are on hand before scheduled work.<\/p>\n<\/li>\n<li>\n<p>Maintain accurate records of maintenance activities and work orders.<\/p>\n<\/li>\n<li>\n<p>Communicate regularly with team members to provide updates on equipment status and upcoming scheduled work.<\/p>\n<\/li>\n<li>\n<p>Ensure all maintenance work follows company safety standards and MSHA regulations.<\/p>\n<\/li>\n<\/ul>\n<h3><strong>Qualifications<\/strong><\/h3>\n<ul>\n<li>\n<p>High school diploma or equivalent required; technical or business coursework preferred.<\/p>\n<\/li>\n<li>\n<p>Previous experience in maintenance planning or scheduling, preferably in mining, construction, or a heavy equipment environment.<\/p>\n<\/li>\n<li>\n<p>Strong understanding of maintenance operations and mobile equipment.<\/p>\n<\/li>\n<li>\n<p>Proficiency in scheduling software and Microsoft Office (Excel required).<\/p>\n<\/li>\n<li>\n<p>Excellent organizational and communication skills.<\/p>\n<\/li>\n<li>\n<p>Valid driver\u2019s license with a clean driving record.<\/p>\n<\/li>\n<\/ul>\n<h3><strong>Physical Requirements<\/strong><\/h3>\n<ul>\n<li>\n<p>Ability to work in both office and field settings.<\/p>\n<\/li>\n<li>\n<p>Comfortable standing or walking for extended periods.<\/p>\n<\/li>\n<li>\n<p>Ability to work in varying weather conditions (heat, cold, dust).<\/p><\/li><li><p>Must pass pre-employment and random drug testing as required<\/p><\/li><\/ul><p><\/p><p><br><strong>Benefits:<br><br><\/strong>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.<br><br>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><p><\/p>","%category%":"Other","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/f08c0abad316-site-administrator-maintenance-planner","%breezy_id%":"f08c0abad316","%breezy_friendly_id%":"f08c0abad316-site-administrator-maintenance-planner","%breezy_created_date%":"2025-07-15T19:45:50.167Z","%breezy_updated_date%":"2025-07-23T12:57:50.841Z","%_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.9391746","%_wpgmp_metabox_longitude%":"-102.2522487","%rank_math_internal_links_processed%":"1"}},"id":2605,"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    Position Overview We are seeking an experienced Field Superintendent to oversee sitework and civil construction operations across multiple projects simultaneously,&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/field-superintendent\/\" name=\"Field Superintendent- Heavy Civil\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Position Overview We are seeking an experienced Field Superintendent to oversee sitework and civil construction operations across multiple projects simultaneously,&hellip;","address":"Atlanta, GA, USA","location":{"lat":"33.7501275","city":"Atlanta","state":"GA","country":"United States","lng":"-84.3885209","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/field-superintendent\/","zoom":19,"extra_fields":{"post_excerpt":"Position Overview We are seeking an experienced Field Superintendent to oversee sitework and civil construction operations across multiple projects simultaneously,&hellip;","post_content":"<p><strong>Position Overview<\/strong><\/p>\n<p>We are seeking an experienced Field Superintendent to oversee sitework and civil construction operations across multiple projects simultaneously, ensuring work is completed safely, on schedule, within budget, and to quality standards. The Field Superintendent will serve as the primary on-site leader for construction projects, coordinating with subcontractors, managing multiple crews, and maintaining project specifications.&nbsp;<\/p>\n<p><strong>Key Responsibilities<\/strong><\/p>\n<p><strong>Project Management &amp; Coordination<\/strong><\/p>\n<ul>\n <li>Supervise daily      construction activities across multiple concurrent projects<\/li>\n <li>Coordinate work      among multiple trades, subcontractors, and crews on various job sites<\/li>\n <li>Review project      plans, specifications, and schedules to ensure compliance and timely      completion<\/li>\n <li>Conduct regular      progress meetings with project teams, subcontractors, and stakeholders<\/li>\n <li>Monitor project      milestones across all active projects and communicate status updates to      project management team<\/li>\n <li>Coordinate      material deliveries and equipment scheduling to maintain workflow      efficiency across multiple sites<\/li>\n <li>Prioritize      resources and crews based on project urgency and scheduling requirements<\/li>\n<\/ul>\n<p><strong>Safety &amp; Compliance<\/strong><\/p>\n<ul>\n <li>Enforce all      safety protocols and OSHA regulations on job sites<\/li>\n <li>Conduct daily      safety meetings and toolbox talks with crews<\/li>\n <li>Perform regular      safety inspections and address hazards immediately<\/li>\n <li>Ensure all      workers have proper safety equipment and training<\/li>\n <li>Maintain      accurate safety documentation and incident reports<\/li>\n<\/ul>\n<p><strong>Quality Control &amp; Assurance<\/strong><\/p>\n<ul>\n <li>Inspect work      progress to ensure adherence to project specifications and quality      standards<\/li>\n <li>Identify and      resolve construction issues before they impact schedule or budget<\/li>\n <li>Coordinate with      quality control inspectors and ensure all work meets code requirements<\/li>\n <li>Document      progress through photos, reports, and quality checklists<\/li>\n <li>Manage punch      list items and ensure completion before project closeout<\/li>\n<\/ul>\n<p><strong>Team Leadership &amp; Communication<\/strong><\/p>\n<ul>\n <li>Lead and      motivate multiple field crews across various project sites to maintain      high productivity and morale<\/li>\n <li>Resolve      conflicts and coordinate between different trades and subcontractors on      multiple projects<\/li>\n <li>Communicate      effectively with project managers, engineers, architects, and clients      across all active projects<\/li>\n <li>Provide      guidance and mentorship to junior field staff and crew leaders<\/li>\n <li>Maintain      positive relationships with all project stakeholders while managing      multiple project demands<\/li>\n<\/ul>\n<p><strong>Required Qualifications<\/strong><\/p>\n<p><strong>Education &amp; Experience<\/strong><\/p>\n<ul>\n <li>High school      diploma or equivalent required; construction management or related degree      preferred<\/li>\n <li>Minimum 5-7      years of sitework\/civil construction experience with at least 3 years in      supervisory role<\/li>\n <li>Experience with      earthwork, grading, utilities, paving, and site development projects<\/li>\n <li>Demonstrated      track record of successful horizontal construction project completion<\/li>\n<\/ul>\n<p><strong>Technical Skills<\/strong><\/p>\n<ul>\n <li>Proficient in      reading and interpreting civil engineering drawings, grading plans, and      utility layouts<\/li>\n <li>Knowledge of      sitework methods, materials, and civil construction practices<\/li>\n <li>Familiarity      with construction management software and project scheduling tools<\/li>\n <li>Strong      understanding of surveying principles, GPS\/laser systems, and site layout      procedures<\/li>\n <li>Knowledge of      soil conditions, compaction requirements, and earthwork operations<\/li>\n <li>Basic computer      skills including Microsoft Office Suite<\/li>\n<\/ul>\n<p><strong>Certifications &amp; Licenses<\/strong><\/p>\n<ul>\n <li>OSHA 30-Hour      Construction Safety certification required<\/li>\n <li>Valid driver's      license with clean driving record<\/li>\n <li>First Aid\/CPR      certification preferred<\/li>\n <li>Additional      trade-specific certifications a plus<\/li>\n<\/ul>\n<p><strong>Preferred Qualifications<\/strong><\/p>\n<ul>\n <li>Bilingual      capabilities (English\/Spanish)<\/li>\n <li>Experience with      sitework and civil construction projects including earthwork, utilities,      and paving<\/li>\n <li>Knowledge of      heavy equipment operations and capabilities<\/li>\n <li>Experience with      stormwater management and erosion control practices<\/li>\n<\/ul>","post_title":"Field Superintendent- Heavy Civil","post_link":"https:\/\/turnerstaffing.com\/position\/field-superintendent\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Mid Level","%location_country%":"United States","%location_city%":"Atlanta","%location_state_id%":"GA","%location_state_name%":"Georgia","%location_city_state%":"Atlanta, GA","%education%":"Unspecified","%department%":"","%description%":"<p><strong>Position Overview<\/strong><\/p>\n<p>We are seeking an experienced Field Superintendent to oversee sitework and civil construction operations across multiple projects simultaneously, ensuring work is completed safely, on schedule, within budget, and to quality standards. The Field Superintendent will serve as the primary on-site leader for construction projects, coordinating with subcontractors, managing multiple crews, and maintaining project specifications.&nbsp;<\/p>\n<p><strong>Key Responsibilities<\/strong><\/p>\n<p><strong>Project Management &amp; Coordination<\/strong><\/p>\n<ul>\n <li>Supervise daily      construction activities across multiple concurrent projects<\/li>\n <li>Coordinate work      among multiple trades, subcontractors, and crews on various job sites<\/li>\n <li>Review project      plans, specifications, and schedules to ensure compliance and timely      completion<\/li>\n <li>Conduct regular      progress meetings with project teams, subcontractors, and stakeholders<\/li>\n <li>Monitor project      milestones across all active projects and communicate status updates to      project management team<\/li>\n <li>Coordinate      material deliveries and equipment scheduling to maintain workflow      efficiency across multiple sites<\/li>\n <li>Prioritize      resources and crews based on project urgency and scheduling requirements<\/li>\n<\/ul>\n<p><strong>Safety &amp; Compliance<\/strong><\/p>\n<ul>\n <li>Enforce all      safety protocols and OSHA regulations on job sites<\/li>\n <li>Conduct daily      safety meetings and toolbox talks with crews<\/li>\n <li>Perform regular      safety inspections and address hazards immediately<\/li>\n <li>Ensure all      workers have proper safety equipment and training<\/li>\n <li>Maintain      accurate safety documentation and incident reports<\/li>\n<\/ul>\n<p><strong>Quality Control &amp; Assurance<\/strong><\/p>\n<ul>\n <li>Inspect work      progress to ensure adherence to project specifications and quality      standards<\/li>\n <li>Identify and      resolve construction issues before they impact schedule or budget<\/li>\n <li>Coordinate with      quality control inspectors and ensure all work meets code requirements<\/li>\n <li>Document      progress through photos, reports, and quality checklists<\/li>\n <li>Manage punch      list items and ensure completion before project closeout<\/li>\n<\/ul>\n<p><strong>Team Leadership &amp; Communication<\/strong><\/p>\n<ul>\n <li>Lead and      motivate multiple field crews across various project sites to maintain      high productivity and morale<\/li>\n <li>Resolve      conflicts and coordinate between different trades and subcontractors on      multiple projects<\/li>\n <li>Communicate      effectively with project managers, engineers, architects, and clients      across all active projects<\/li>\n <li>Provide      guidance and mentorship to junior field staff and crew leaders<\/li>\n <li>Maintain      positive relationships with all project stakeholders while managing      multiple project demands<\/li>\n<\/ul>\n<p><strong>Required Qualifications<\/strong><\/p>\n<p><strong>Education &amp; Experience<\/strong><\/p>\n<ul>\n <li>High school      diploma or equivalent required; construction management or related degree      preferred<\/li>\n <li>Minimum 5-7      years of sitework\/civil construction experience with at least 3 years in      supervisory role<\/li>\n <li>Experience with      earthwork, grading, utilities, paving, and site development projects<\/li>\n <li>Demonstrated      track record of successful horizontal construction project completion<\/li>\n<\/ul>\n<p><strong>Technical Skills<\/strong><\/p>\n<ul>\n <li>Proficient in      reading and interpreting civil engineering drawings, grading plans, and      utility layouts<\/li>\n <li>Knowledge of      sitework methods, materials, and civil construction practices<\/li>\n <li>Familiarity      with construction management software and project scheduling tools<\/li>\n <li>Strong      understanding of surveying principles, GPS\/laser systems, and site layout      procedures<\/li>\n <li>Knowledge of      soil conditions, compaction requirements, and earthwork operations<\/li>\n <li>Basic computer      skills including Microsoft Office Suite<\/li>\n<\/ul>\n<p><strong>Certifications &amp; Licenses<\/strong><\/p>\n<ul>\n <li>OSHA 30-Hour      Construction Safety certification required<\/li>\n <li>Valid driver's      license with clean driving record<\/li>\n <li>First Aid\/CPR      certification preferred<\/li>\n <li>Additional      trade-specific certifications a plus<\/li>\n<\/ul>\n<p><strong>Preferred Qualifications<\/strong><\/p>\n<ul>\n <li>Bilingual      capabilities (English\/Spanish)<\/li>\n <li>Experience with      sitework and civil construction projects including earthwork, utilities,      and paving<\/li>\n <li>Knowledge of      heavy equipment operations and capabilities<\/li>\n <li>Experience with      stormwater management and erosion control practices<\/li>\n<\/ul>","%category%":"Management","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/d54a64351ddb-field-superintendent-heavy-civil","%breezy_id%":"d54a64351ddb","%breezy_friendly_id%":"d54a64351ddb-field-superintendent-heavy-civil","%breezy_created_date%":"2025-07-10T16:32:03.430Z","%breezy_updated_date%":"2025-08-04T13:08:47.035Z","%_wpgmp_location_city%":"Atlanta","%_wpgmp_location_state%":"GA","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Atlanta, GA, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"33.7501275","%_wpgmp_metabox_longitude%":"-84.3885209","%rank_math_internal_links_processed%":"1"}},"id":2604,"infowindow_disable":false},{"source":"post","title":"Land GPS Surveyor","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Land GPS Surveyor\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Position Overview We are seeking a mid-level Land\/GPS Surveyor to join our team. The successful candidate will be responsible for&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/land-gps-surveyor\/\" name=\"Land GPS Surveyor\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Position Overview We are seeking a mid-level Land\/GPS Surveyor to join our team. The successful candidate will be responsible for&hellip;","address":"Atlanta, GA, USA","location":{"lat":"33.7501275","city":"Atlanta","state":"GA","country":"United States","lng":"-84.3885209","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/land-gps-surveyor\/","zoom":19,"extra_fields":{"post_excerpt":"Position Overview We are seeking a mid-level Land\/GPS Surveyor to join our team. The successful candidate will be responsible for&hellip;","post_content":"<p><strong>Position Overview<\/strong><\/p>\n<p>We are seeking a mid-level Land\/GPS Surveyor to join our team. The successful candidate will be responsible for conducting precise land surveys using advanced GPS technology and traditional surveying methods. This role requires strong technical skills, attention to detail, and the ability to work independently while contributing to complex surveying projects.<\/p>\n<p><strong>Key Responsibilities<\/strong><\/p>\n<p><strong>Field Survey Operations<\/strong><\/p>\n<ul>\n <li>Conduct      boundary surveys, topographic surveys, and construction staking using      GPS\/GNSS equipment, total stations, and data collectors<\/li>\n <li>Collect and      process field data using GPS technology and conventional surveying      instruments<\/li>\n <li>Establish and      maintain control points and benchmarks<\/li>\n<\/ul>\n<p><strong>Technical Skills &amp; Documentation<\/strong><\/p>\n<ul>\n <li>Operate and      maintain GPS receivers, total stations, levels, and other surveying      equipment<\/li>\n <li>Process survey      data using industry-standard software (AutoCAD, Civil 3D, Trimble Business      Center, AgTek or similar)<\/li>\n <li>Prepare      detailed survey reports, maps, and legal descriptions<\/li>\n <li>Review and      interpret deeds, plats, and other legal documents<\/li>\n <li>Maintain      accurate field notes and documentation<\/li>\n<\/ul>\n<p><strong>Project Management &amp; Collaboration<\/strong><\/p>\n<ul>\n <li>Work      independently on assigned projects while meeting deadlines<\/li>\n <li>Coordinate with      project managers, estimators, and clients<\/li>\n <li>Ensure      compliance with state regulations and professional standards<\/li>\n <li>Communicate      effectively with clients regarding project progress and findings<\/li>\n<\/ul>\n<p><strong>Required Qualifications<\/strong><\/p>\n<p><strong>Education &amp; Licensing<\/strong><\/p>\n<ul>\n <li>Associate's      degree in Surveying, Geomatics, or related field, OR equivalent experience<\/li>\n <li>Valid state      surveyor license or ability to obtain licensure within 12 months<\/li>\n<\/ul>\n<p><strong>Experience<\/strong><\/p>\n<ul>\n <li>2-5 years of      professional land surveying experience<\/li>\n <li>Proven      experience with GPS\/GNSS surveying systems<\/li>\n <li>Experience with      boundary surveys and property research<\/li>\n <li>Knowledge of      local surveying practices and regulations<\/li>\n<\/ul>\n<p><strong>Technical Competencies<\/strong><\/p>\n<ul>\n <li>Proficiency      with GPS equipment (Trimble, Leica, Topcon, or similar)<\/li>\n <li>Experience with      total stations and conventional surveying instruments<\/li>\n <li>Proficiency in      AutoCAD, AgTek and surveying software applications<\/li>\n <li>Strong      mathematical and analytical skills<\/li>\n <li>Ability to read      and interpret construction plans <\/li>\n<\/ul>\n<p><strong>Professional Skills<\/strong><\/p>\n<ul>\n <li>Excellent      attention to detail and accuracy<\/li>\n <li>Strong written      and verbal communication skills<\/li>\n <li>Ability to work      independently and manage multiple projects<\/li>\n <li>Valid driver's      license <\/li>\n <li>Physical      ability to work outdoors in various weather conditions<\/li>\n<\/ul>\n<p><strong>Preferred Qualifications - OPTIONAL<\/strong><\/p>\n<ul>\n <li>Bachelor's      degree in Surveying, Civil Engineering, or related field<\/li>\n <li>Professional      Land Surveyor (PLS) license<\/li>\n <li>Experience with      construction layout and engineering surveys<\/li>\n <li>Knowledge of      GIS applications and data management<\/li>\n <li>OSHA 10-hour      safety certification<\/li>\n<\/ul>","post_title":"Land GPS Surveyor","post_link":"https:\/\/turnerstaffing.com\/position\/land-gps-surveyor\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Mid Level","%location_country%":"United States","%location_city%":"Atlanta","%location_state_id%":"GA","%location_state_name%":"Georgia","%location_city_state%":"Atlanta, GA","%education%":"Unspecified","%department%":"","%description%":"<p><strong>Position Overview<\/strong><\/p>\n<p>We are seeking a mid-level Land\/GPS Surveyor to join our team. The successful candidate will be responsible for conducting precise land surveys using advanced GPS technology and traditional surveying methods. This role requires strong technical skills, attention to detail, and the ability to work independently while contributing to complex surveying projects.<\/p>\n<p><strong>Key Responsibilities<\/strong><\/p>\n<p><strong>Field Survey Operations<\/strong><\/p>\n<ul>\n <li>Conduct      boundary surveys, topographic surveys, and construction staking using      GPS\/GNSS equipment, total stations, and data collectors<\/li>\n <li>Collect and      process field data using GPS technology and conventional surveying      instruments<\/li>\n <li>Establish and      maintain control points and benchmarks<\/li>\n<\/ul>\n<p><strong>Technical Skills &amp; Documentation<\/strong><\/p>\n<ul>\n <li>Operate and      maintain GPS receivers, total stations, levels, and other surveying      equipment<\/li>\n <li>Process survey      data using industry-standard software (AutoCAD, Civil 3D, Trimble Business      Center, AgTek or similar)<\/li>\n <li>Prepare      detailed survey reports, maps, and legal descriptions<\/li>\n <li>Review and      interpret deeds, plats, and other legal documents<\/li>\n <li>Maintain      accurate field notes and documentation<\/li>\n<\/ul>\n<p><strong>Project Management &amp; Collaboration<\/strong><\/p>\n<ul>\n <li>Work      independently on assigned projects while meeting deadlines<\/li>\n <li>Coordinate with      project managers, estimators, and clients<\/li>\n <li>Ensure      compliance with state regulations and professional standards<\/li>\n <li>Communicate      effectively with clients regarding project progress and findings<\/li>\n<\/ul>\n<p><strong>Required Qualifications<\/strong><\/p>\n<p><strong>Education &amp; Licensing<\/strong><\/p>\n<ul>\n <li>Associate's      degree in Surveying, Geomatics, or related field, OR equivalent experience<\/li>\n <li>Valid state      surveyor license or ability to obtain licensure within 12 months<\/li>\n<\/ul>\n<p><strong>Experience<\/strong><\/p>\n<ul>\n <li>2-5 years of      professional land surveying experience<\/li>\n <li>Proven      experience with GPS\/GNSS surveying systems<\/li>\n <li>Experience with      boundary surveys and property research<\/li>\n <li>Knowledge of      local surveying practices and regulations<\/li>\n<\/ul>\n<p><strong>Technical Competencies<\/strong><\/p>\n<ul>\n <li>Proficiency      with GPS equipment (Trimble, Leica, Topcon, or similar)<\/li>\n <li>Experience with      total stations and conventional surveying instruments<\/li>\n <li>Proficiency in      AutoCAD, AgTek and surveying software applications<\/li>\n <li>Strong      mathematical and analytical skills<\/li>\n <li>Ability to read      and interpret construction plans <\/li>\n<\/ul>\n<p><strong>Professional Skills<\/strong><\/p>\n<ul>\n <li>Excellent      attention to detail and accuracy<\/li>\n <li>Strong written      and verbal communication skills<\/li>\n <li>Ability to work      independently and manage multiple projects<\/li>\n <li>Valid driver's      license <\/li>\n <li>Physical      ability to work outdoors in various weather conditions<\/li>\n<\/ul>\n<p><strong>Preferred Qualifications - OPTIONAL<\/strong><\/p>\n<ul>\n <li>Bachelor's      degree in Surveying, Civil Engineering, or related field<\/li>\n <li>Professional      Land Surveyor (PLS) license<\/li>\n <li>Experience with      construction layout and engineering surveys<\/li>\n <li>Knowledge of      GIS applications and data management<\/li>\n <li>OSHA 10-hour      safety certification<\/li>\n<\/ul>","%category%":"Operations","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/26a5513eb852-land-gps-surveyor","%breezy_id%":"26a5513eb852","%breezy_friendly_id%":"26a5513eb852-land-gps-surveyor","%breezy_created_date%":"2025-07-10T16:27:19.273Z","%breezy_updated_date%":"2025-07-10T16:28:03.733Z","%_wpgmp_location_city%":"Atlanta","%_wpgmp_location_state%":"GA","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Atlanta, GA, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"33.7501275","%_wpgmp_metabox_longitude%":"-84.3885209","%rank_math_internal_links_processed%":"1"}},"id":2602,"infowindow_disable":false},{"source":"post","title":"CDL Maintenance and Truck Shop Manager","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    CDL Maintenance and Truck Shop Manager\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Position Summary: We are seeking a highly skilled and organized CDL Maintenance and Truck Shop Manager to oversee all aspects&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/cdl-maintenance-and-truck-shop-manager\/\" name=\"CDL Maintenance and Truck Shop Manager\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Position Summary: We are seeking a highly skilled and organized CDL Maintenance and Truck Shop Manager to oversee all aspects&hellip;","address":"Atlanta, GA, USA","location":{"lat":"33.7501275","city":"Atlanta","state":"GA","country":"United States","lng":"-84.3885209","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/cdl-maintenance-and-truck-shop-manager\/","zoom":19,"extra_fields":{"post_excerpt":"Position Summary: We are seeking a highly skilled and organized CDL Maintenance and Truck Shop Manager to oversee all aspects&hellip;","post_content":"<p><strong>Position Summary:<\/strong><\/p>\n<p>We are seeking a highly skilled and organized CDL Maintenance and Truck Shop Manager to oversee all aspects of our fleet maintenance operations. This role is responsible for managing daily shop activities, coordinating repairs and preventative maintenance, supervising a team of mechanics\/technicians, and ensuring compliance with DOT regulations. The ideal candidate will have a strong background in heavy-duty truck maintenance, a valid CDL (Class A or B), and proven leadership experience in a shop environment.<\/p>\n<p><strong>Key Responsibilities:<\/strong><\/p>\n<ul>\n <li>Supervise      and coordinate the activities of all shop personnel, including      technicians, service writers, and parts personnel.<\/li>\n <li>Schedule      and oversee preventative maintenance, diagnostics, and repairs on a fleet      of trucks, trailers, and other commercial vehicles.<\/li>\n <li>Ensure      all vehicles meet safety and regulatory standards (DOT\/FMCSA).<\/li>\n <li>Maintain      accurate maintenance records, repair logs, and compliance documentation.<\/li>\n <li>Perform      hands-on maintenance and diagnostics when necessary.<\/li>\n <li>Monitor      and manage inventory levels for parts and supplies; work with vendors to      order and restock as needed.<\/li>\n <li>Develop      and implement maintenance schedules and ensure timely inspections.<\/li>\n <li>Track      costs, labor, and equipment downtime to improve efficiency and reduce      overhead.<\/li>\n <li>Train      and mentor shop staff; support career development and safety compliance.<\/li>\n <li>Collaborate      with dispatch and operations teams to minimize downtime and disruptions.<\/li>\n <li>Enforce      workplace safety policies and OSHA standards.<\/li>\n<\/ul>\n<p><strong>Qualifications:<\/strong><\/p>\n<ul>\n <li>High      school diploma or equivalent; technical or vocational training preferred.<\/li>\n <li>Valid      CDL Class A or B required.<\/li>\n <li>Minimum      5 years of experience in truck maintenance with at least 2 years in a      supervisory or managerial role.<\/li>\n <li>Strong      knowledge of diesel engines, air brake systems, hydraulics, electrical      systems, and diagnostic tools.<\/li>\n <li>Proficiency      with fleet maintenance software (e.g., Fleetio, &nbsp;or similar).<\/li>\n <li>Excellent      organizational, communication, and leadership skills.<\/li>\n <li>Strong      understanding of DOT and OSHA regulations.<\/li>\n <li>Ability      to lift up to 75 lbs and work in physically demanding environments as      needed.<\/li>\n<\/ul>\n<p><strong>Preferred Skills:<\/strong><\/p>\n<ul>\n <li>ASE      certifications or OEM-specific training are a plus.<\/li>\n <li>Experience      with budgeting and cost control.<\/li>\n <li>Bilingual      (Spanish\/English) is a plus, but not required.<\/li>\n<\/ul>\n<p><strong>Working Conditions:<\/strong><\/p>\n<ul>\n <li>Split      between office\/shop floor and occasional fieldwork.<\/li>\n <li>May      require evening or weekend availability depending on fleet demands.<\/li>\n <li>Fast-paced,      high-responsibility environment.<\/li>\n<\/ul>","post_title":"CDL Maintenance and Truck Shop Manager","post_link":"https:\/\/turnerstaffing.com\/position\/cdl-maintenance-and-truck-shop-manager\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Mid Level","%location_country%":"United States","%location_city%":"Atlanta","%location_state_id%":"GA","%location_state_name%":"Georgia","%location_city_state%":"Atlanta, GA","%education%":"Unspecified","%department%":"","%description%":"<p><strong>Position Summary:<\/strong><\/p>\n<p>We are seeking a highly skilled and organized CDL Maintenance and Truck Shop Manager to oversee all aspects of our fleet maintenance operations. This role is responsible for managing daily shop activities, coordinating repairs and preventative maintenance, supervising a team of mechanics\/technicians, and ensuring compliance with DOT regulations. The ideal candidate will have a strong background in heavy-duty truck maintenance, a valid CDL (Class A or B), and proven leadership experience in a shop environment.<\/p>\n<p><strong>Key Responsibilities:<\/strong><\/p>\n<ul>\n <li>Supervise      and coordinate the activities of all shop personnel, including      technicians, service writers, and parts personnel.<\/li>\n <li>Schedule      and oversee preventative maintenance, diagnostics, and repairs on a fleet      of trucks, trailers, and other commercial vehicles.<\/li>\n <li>Ensure      all vehicles meet safety and regulatory standards (DOT\/FMCSA).<\/li>\n <li>Maintain      accurate maintenance records, repair logs, and compliance documentation.<\/li>\n <li>Perform      hands-on maintenance and diagnostics when necessary.<\/li>\n <li>Monitor      and manage inventory levels for parts and supplies; work with vendors to      order and restock as needed.<\/li>\n <li>Develop      and implement maintenance schedules and ensure timely inspections.<\/li>\n <li>Track      costs, labor, and equipment downtime to improve efficiency and reduce      overhead.<\/li>\n <li>Train      and mentor shop staff; support career development and safety compliance.<\/li>\n <li>Collaborate      with dispatch and operations teams to minimize downtime and disruptions.<\/li>\n <li>Enforce      workplace safety policies and OSHA standards.<\/li>\n<\/ul>\n<p><strong>Qualifications:<\/strong><\/p>\n<ul>\n <li>High      school diploma or equivalent; technical or vocational training preferred.<\/li>\n <li>Valid      CDL Class A or B required.<\/li>\n <li>Minimum      5 years of experience in truck maintenance with at least 2 years in a      supervisory or managerial role.<\/li>\n <li>Strong      knowledge of diesel engines, air brake systems, hydraulics, electrical      systems, and diagnostic tools.<\/li>\n <li>Proficiency      with fleet maintenance software (e.g., Fleetio, &nbsp;or similar).<\/li>\n <li>Excellent      organizational, communication, and leadership skills.<\/li>\n <li>Strong      understanding of DOT and OSHA regulations.<\/li>\n <li>Ability      to lift up to 75 lbs and work in physically demanding environments as      needed.<\/li>\n<\/ul>\n<p><strong>Preferred Skills:<\/strong><\/p>\n<ul>\n <li>ASE      certifications or OEM-specific training are a plus.<\/li>\n <li>Experience      with budgeting and cost control.<\/li>\n <li>Bilingual      (Spanish\/English) is a plus, but not required.<\/li>\n<\/ul>\n<p><strong>Working Conditions:<\/strong><\/p>\n<ul>\n <li>Split      between office\/shop floor and occasional fieldwork.<\/li>\n <li>May      require evening or weekend availability depending on fleet demands.<\/li>\n <li>Fast-paced,      high-responsibility environment.<\/li>\n<\/ul>","%category%":"Management","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/31854953ee81-cdl-maintenance-and-truck-shop-manager","%breezy_id%":"31854953ee81","%breezy_friendly_id%":"31854953ee81-cdl-maintenance-and-truck-shop-manager","%breezy_created_date%":"2025-07-10T16:29:51.113Z","%breezy_updated_date%":"2025-07-10T16:30:29.342Z","%_wpgmp_location_city%":"Atlanta","%_wpgmp_location_state%":"GA","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Atlanta, GA, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"33.7501275","%_wpgmp_metabox_longitude%":"-84.3885209","%rank_math_internal_links_processed%":"1"}},"id":2603,"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-07-21T16:48:02.873Z","%_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-07-09T18:23:04.948Z","%_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 &#8211; Mining","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Heavy Equipment Operator &#8211; Mining\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\/heavy-equipment-operator-mining\/\" name=\"Heavy Equipment Operator &#8211; Mining\" 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\/heavy-equipment-operator-mining\/","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":"Heavy Equipment Operator &#8211; Mining","post_link":"https:\/\/turnerstaffing.com\/position\/heavy-equipment-operator-mining\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Associate","%location_country%":"United States","%location_city%":"Kingman","%location_state_id%":"AZ","%location_state_name%":"Arizona","%location_city_state%":"Kingman, AZ","%education%":"Unspecified","%department%":"Operations","%description%":"<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\/7ff63bdf1872-heavy-equipment-operator-mining","%breezy_id%":"7ff63bdf1872","%breezy_friendly_id%":"7ff63bdf1872-heavy-equipment-operator-mining","%breezy_created_date%":"2025-07-01T15:43:00.971Z","%breezy_updated_date%":"2025-07-20T15:50:18.871Z","%_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":2585,"infowindow_disable":false},{"source":"post","title":"Heavy Civil Project Manager","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Heavy Civil Project Manager\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    We are seeking a highly skilled and experienced Project Manager to lead and oversee heavy civil construction projects. The ideal&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/project-manager\/\" name=\"Heavy Civil Project Manager\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"We are seeking a highly skilled and experienced Project Manager to lead and oversee heavy civil construction projects. The ideal&hellip;","address":"Green Valley, AZ, USA","location":{"lat":"31.8542511","city":"Green Valley","state":"AZ","country":"United States","lng":"-110.9937019","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/project-manager\/","zoom":19,"extra_fields":{"post_excerpt":"We are seeking a highly skilled and experienced Project Manager to lead and oversee heavy civil construction projects. The ideal&hellip;","post_content":"<p>We are seeking a highly skilled and experienced Project Manager to lead and oversee heavy civil construction projects. The ideal candidate will be responsible for ensuring the successful planning, execution, and completion of large-scale civil projects such as roads, bridges, highways, water treatment plants, or other infrastructure projects. The Project Manager will manage all aspects of the project, from budgeting and scheduling to resource management, ensuring safety, quality, and client satisfaction.<\/p>\n<p><strong>Key Responsibilities:<\/strong><\/p>\n<ul><li><strong>Project Planning and Coordination:<\/strong>&nbsp;Develop comprehensive project plans, schedules, and budgets. Coordinate with internal teams, clients, subcontractors, and vendors to ensure project milestones are met within the defined timelines and budgets.<\/li><li><strong>Team Management:<\/strong>&nbsp;Lead, motivate, and mentor project teams, including engineers, subcontractors, and laborers. Ensure effective communication across all stakeholders.<\/li><li><strong>Cost Control and Budget Management:<\/strong>&nbsp;Monitor project costs and financial performance, identify cost-saving opportunities, and ensure that the project stays within budget.<\/li><li><strong>Quality Assurance and Compliance:<\/strong>&nbsp;Ensure all work adheres to industry standards, regulations, and safety requirements. Perform quality inspections and maintain high standards of work.<\/li><li><strong>Risk Management:<\/strong>&nbsp;Identify potential project risks (safety, financial, logistical) and develop mitigation plans to address and minimize impacts.<\/li><li><strong>Client and Stakeholder Relations:<\/strong>&nbsp;Serve as the primary point of contact for clients and stakeholders. Communicate project progress, manage expectations, and resolve any issues or concerns that arise during the project lifecycle.<\/li><li><strong>Procurement and Contract Management:<\/strong>&nbsp;Manage procurement of materials, equipment, and services. Negotiate contracts with suppliers and subcontractors, ensuring compliance with project terms.<\/li><li><strong>Reporting and Documentation:<\/strong>&nbsp;Maintain detailed project documentation, including progress reports, change orders, meeting minutes, and financial reports. Provide regular updates to senior management and clients.<\/li><li><strong>Safety Management:<\/strong>&nbsp;Enforce safety policies and procedures, ensuring all worksite activities comply with OSHA and other local safety regulations.<\/li><\/ul>\n<p><strong>Qualifications:<\/strong><\/p>\n<ul><li>Bachelor\u2019s degree in Civil Engineering, Construction Management, or related field (preferred).<\/li><li>Minimum of 2 years of experience in heavy civil construction project management.<\/li><li>Proven experience managing large-scale infrastructure projects (roads, bridges, utilities, etc.).<\/li><li>Strong understanding of construction methods, cost estimating, budgeting, and scheduling.<\/li><li>Experience with project management software (e.g., Procore, MS Project, Primavera).<\/li><li>Excellent leadership, communication, and interpersonal skills.<\/li><li>Ability to work under pressure and meet deadlines while maintaining quality and safety.<\/li><li>Strong problem-solving and decision-making skills.<\/li><li>Knowledge of construction safety standards and regulations (OSHA).<\/li><li>PMP (Project Management Professional) certification or equivalent is a plus.<\/li><\/ul>","post_title":"Heavy Civil Project Manager","post_link":"https:\/\/turnerstaffing.com\/position\/project-manager\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Senior","%location_country%":"United States","%location_city%":"Green Valley","%location_state_id%":"AZ","%location_state_name%":"Arizona","%location_city_state%":"Green Valley, AZ","%education%":"Unspecified","%department%":"","%description%":"<p>We are seeking a highly skilled and experienced Project Manager to lead and oversee heavy civil construction projects. The ideal candidate will be responsible for ensuring the successful planning, execution, and completion of large-scale civil projects such as roads, bridges, highways, water treatment plants, or other infrastructure projects. The Project Manager will manage all aspects of the project, from budgeting and scheduling to resource management, ensuring safety, quality, and client satisfaction.<\/p>\n<p><strong>Key Responsibilities:<\/strong><\/p>\n<ul><li><strong>Project Planning and Coordination:<\/strong>&nbsp;Develop comprehensive project plans, schedules, and budgets. Coordinate with internal teams, clients, subcontractors, and vendors to ensure project milestones are met within the defined timelines and budgets.<\/li><li><strong>Team Management:<\/strong>&nbsp;Lead, motivate, and mentor project teams, including engineers, subcontractors, and laborers. Ensure effective communication across all stakeholders.<\/li><li><strong>Cost Control and Budget Management:<\/strong>&nbsp;Monitor project costs and financial performance, identify cost-saving opportunities, and ensure that the project stays within budget.<\/li><li><strong>Quality Assurance and Compliance:<\/strong>&nbsp;Ensure all work adheres to industry standards, regulations, and safety requirements. Perform quality inspections and maintain high standards of work.<\/li><li><strong>Risk Management:<\/strong>&nbsp;Identify potential project risks (safety, financial, logistical) and develop mitigation plans to address and minimize impacts.<\/li><li><strong>Client and Stakeholder Relations:<\/strong>&nbsp;Serve as the primary point of contact for clients and stakeholders. Communicate project progress, manage expectations, and resolve any issues or concerns that arise during the project lifecycle.<\/li><li><strong>Procurement and Contract Management:<\/strong>&nbsp;Manage procurement of materials, equipment, and services. Negotiate contracts with suppliers and subcontractors, ensuring compliance with project terms.<\/li><li><strong>Reporting and Documentation:<\/strong>&nbsp;Maintain detailed project documentation, including progress reports, change orders, meeting minutes, and financial reports. Provide regular updates to senior management and clients.<\/li><li><strong>Safety Management:<\/strong>&nbsp;Enforce safety policies and procedures, ensuring all worksite activities comply with OSHA and other local safety regulations.<\/li><\/ul>\n<p><strong>Qualifications:<\/strong><\/p>\n<ul><li>Bachelor\u2019s degree in Civil Engineering, Construction Management, or related field (preferred).<\/li><li>Minimum of 2 years of experience in heavy civil construction project management.<\/li><li>Proven experience managing large-scale infrastructure projects (roads, bridges, utilities, etc.).<\/li><li>Strong understanding of construction methods, cost estimating, budgeting, and scheduling.<\/li><li>Experience with project management software (e.g., Procore, MS Project, Primavera).<\/li><li>Excellent leadership, communication, and interpersonal skills.<\/li><li>Ability to work under pressure and meet deadlines while maintaining quality and safety.<\/li><li>Strong problem-solving and decision-making skills.<\/li><li>Knowledge of construction safety standards and regulations (OSHA).<\/li><li>PMP (Project Management Professional) certification or equivalent is a plus.<\/li><\/ul>","%category%":"Management","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/d1cc7c912f7e-heavy-civil-project-manager","%breezy_id%":"d1cc7c912f7e","%breezy_friendly_id%":"d1cc7c912f7e-heavy-civil-project-manager","%breezy_created_date%":"2025-06-30T20:55:58.770Z","%breezy_updated_date%":"2025-07-10T18:15:48.272Z","%_wpgmp_location_city%":"Green Valley","%_wpgmp_location_state%":"AZ","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Green Valley, AZ, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"31.8542511","%_wpgmp_metabox_longitude%":"-110.9937019","%rank_math_internal_links_processed%":"1"}},"id":2582,"infowindow_disable":false},{"source":"post","title":"Land Surveyor","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Land Surveyor\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Key Responsibilities: Expand In-House Surveying Capabilities: &#8211; Support our team\u2019s transition away from outsourcing by developing in-house licensed surveying services.&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/land-surveyor\/\" name=\"Land Surveyor\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Key Responsibilities: Expand In-House Surveying Capabilities: &#8211; Support our team\u2019s transition away from outsourcing by developing in-house licensed surveying services.&hellip;","address":"Atlanta, GA, USA","location":{"lat":"33.7501275","city":"Atlanta","state":"GA","country":"United States","lng":"-84.3885209","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/land-surveyor\/","zoom":19,"extra_fields":{"post_excerpt":"Key Responsibilities: Expand In-House Surveying Capabilities: &#8211; Support our team\u2019s transition away from outsourcing by developing in-house licensed surveying services.&hellip;","post_content":"<p><strong>Key Responsibilities:<\/strong><\/p>\n<p><\/p>\n<p><strong>Expand In-House Surveying Capabilities:<\/strong><\/p>\n<p>- Support our team\u2019s transition away from outsourcing by developing in-house licensed surveying services.<\/p>\n<p>- Provide professional certification, review, and approval of surveying and mapping deliverables.<\/p>\n<p>- Help our team obtain and maintain surveying licenses in multiple states where we operate.<\/p>\n<p><\/p>\n<p><strong>Professional Surveying &amp; Compliance:<\/strong><\/p>\n<p>- Serve as the licensed surveyor of record in states where we offer professional surveying services.<\/p>\n<p>- Ensure regulatory compliance with state and federal land surveying laws.<\/p>\n<p>- Oversee boundary, topographic, and volumetric surveys for mining, landfill, and utility projects.<\/p>\n<p><\/p>\n<p><strong>Geospatial Data Validation &amp; Integration:<\/strong><\/p>\n<p>- Support UAV-based LiDAR and photogrammetry processing, ensuring accuracy for stockpile measurement, terrain modeling, and volumetric calculations.<\/p>\n<p>- Develop workflows for integrating ground control points (GCPs), RTK\/PPK corrections, and GPS survey data into our deliverables.<\/p>\n<p>- Perform QA\/QC on drone and mobile mapping datasets to ensure survey-grade accuracy.<\/p>\n<p><\/p>\n<p><strong>Field Surveying &amp; Remote Sensing Support:<\/strong><\/p>\n<p>- Conduct ground-based and UAV-assisted survey operations, including boundary surveys, topographic mapping, and site inspections.<\/p>\n<p>- Assist in developing methodologies for subsurface mines, landfill topography monitoring, and utility inspections.<\/p>\n<p>- Work with engineering and GIS teams to enhance reality capture workflows for site modeling.<\/p>\n<p><\/p>\n<p><strong>Client &amp; Regulatory Engagement:<\/strong><\/p>\n<p>- Interface with clients to understand project needs and expand our licensed surveyor services.<\/p>\n<p>- Prepare and certify legal descriptions, boundary maps, and as-built surveys.<\/p>\n<p>- Stay up to date with industry trends and grow our licensing footprint.<\/p>\n<p><\/p>\n<p><\/p>\n<p><strong>Qualifications:<\/strong><br><\/p>\n<ul><li>Possess or ability to obtain reciprocal licenses in states where we operate.<\/li><li>5+ years of experience in land surveying, geomatics, or geospatial engineering.<\/li><li>Strong knowledge of LiDAR, photogrammetry, RTK\/PPK GPS, and UAV-based surveying methodologies.<\/li><li>Proficiency with survey software (e.g., Trimble Business Center, Leica Infinity, Pix4D, Global Mapper, QGIS, AutoCAD Civil 3D).<\/li><li>Experience in mining, solid waste, or utility surveying is a plus.<\/li><\/ul>","post_title":"Land Surveyor","post_link":"https:\/\/turnerstaffing.com\/position\/land-surveyor\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Mid Level","%location_country%":"United States","%location_city%":"Atlanta","%location_state_id%":"GA","%location_state_name%":"Georgia","%location_city_state%":"Atlanta, GA","%education%":"Unspecified","%department%":"","%description%":"<p><strong>Key Responsibilities:<\/strong><\/p>\n<p><\/p>\n<p><strong>Expand In-House Surveying Capabilities:<\/strong><\/p>\n<p>- Support our team\u2019s transition away from outsourcing by developing in-house licensed surveying services.<\/p>\n<p>- Provide professional certification, review, and approval of surveying and mapping deliverables.<\/p>\n<p>- Help our team obtain and maintain surveying licenses in multiple states where we operate.<\/p>\n<p><\/p>\n<p><strong>Professional Surveying &amp; Compliance:<\/strong><\/p>\n<p>- Serve as the licensed surveyor of record in states where we offer professional surveying services.<\/p>\n<p>- Ensure regulatory compliance with state and federal land surveying laws.<\/p>\n<p>- Oversee boundary, topographic, and volumetric surveys for mining, landfill, and utility projects.<\/p>\n<p><\/p>\n<p><strong>Geospatial Data Validation &amp; Integration:<\/strong><\/p>\n<p>- Support UAV-based LiDAR and photogrammetry processing, ensuring accuracy for stockpile measurement, terrain modeling, and volumetric calculations.<\/p>\n<p>- Develop workflows for integrating ground control points (GCPs), RTK\/PPK corrections, and GPS survey data into our deliverables.<\/p>\n<p>- Perform QA\/QC on drone and mobile mapping datasets to ensure survey-grade accuracy.<\/p>\n<p><\/p>\n<p><strong>Field Surveying &amp; Remote Sensing Support:<\/strong><\/p>\n<p>- Conduct ground-based and UAV-assisted survey operations, including boundary surveys, topographic mapping, and site inspections.<\/p>\n<p>- Assist in developing methodologies for subsurface mines, landfill topography monitoring, and utility inspections.<\/p>\n<p>- Work with engineering and GIS teams to enhance reality capture workflows for site modeling.<\/p>\n<p><\/p>\n<p><strong>Client &amp; Regulatory Engagement:<\/strong><\/p>\n<p>- Interface with clients to understand project needs and expand our licensed surveyor services.<\/p>\n<p>- Prepare and certify legal descriptions, boundary maps, and as-built surveys.<\/p>\n<p>- Stay up to date with industry trends and grow our licensing footprint.<\/p>\n<p><\/p>\n<p><\/p>\n<p><strong>Qualifications:<\/strong><br><\/p>\n<ul><li>Possess or ability to obtain reciprocal licenses in states where we operate.<\/li><li>5+ years of experience in land surveying, geomatics, or geospatial engineering.<\/li><li>Strong knowledge of LiDAR, photogrammetry, RTK\/PPK GPS, and UAV-based surveying methodologies.<\/li><li>Proficiency with survey software (e.g., Trimble Business Center, Leica Infinity, Pix4D, Global Mapper, QGIS, AutoCAD Civil 3D).<\/li><li>Experience in mining, solid waste, or utility surveying is a plus.<\/li><\/ul>","%category%":"","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/7434755fd4a9-land-surveyor","%breezy_id%":"7434755fd4a9","%breezy_friendly_id%":"7434755fd4a9-land-surveyor","%breezy_created_date%":"2025-06-30T14:19:48.226Z","%breezy_updated_date%":"2025-06-30T14:21:11.582Z","%_wpgmp_location_city%":"Atlanta","%_wpgmp_location_state%":"GA","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Atlanta, GA, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"33.7501275","%_wpgmp_metabox_longitude%":"-84.3885209","%rank_math_internal_links_processed%":"1"}},"id":2580,"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-07-08T14:19:02.228Z","%_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":"Civil Sitework Project Manager","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Civil Sitework Project Manager\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Job Summary: The Project Manager for our client is responsible for planning, coordinating, and overseeing all phases of sitework construction&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/civil-sitework-project-manager\/\" name=\"Civil Sitework Project Manager\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Job Summary: The Project Manager for our client is responsible for planning, coordinating, and overseeing all phases of sitework construction&hellip;","address":"Atlanta, GA, USA","location":{"lat":"33.7501275","city":"Atlanta","state":"GA","country":"United States","lng":"-84.3885209","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/civil-sitework-project-manager\/","zoom":19,"extra_fields":{"post_excerpt":"Job Summary: The Project Manager for our client is responsible for planning, coordinating, and overseeing all phases of sitework construction&hellip;","post_content":"<p><strong>Job Summary:<\/strong><\/p>\n<p>The Project Manager for our client is responsible for planning, coordinating, and overseeing all phases of sitework construction projects. This includes managing resources, schedules, financials, and adhering to quality and safety standards. The Project Manager ensures that the project is completed on time, within budget, and to the satisfaction of the client.<\/p>\n<p><strong>Key Responsibilities:<\/strong><\/p>\n<p><strong>Project Planning and Coordination:<\/strong><\/p>\n<ul>\n <li>Develop      comprehensive project plans that include timelines, resources, and      budgets.<\/li>\n <li>Coordinate with      clients, architects, engineers, and other stakeholders to define project      scope and objectives.<\/li>\n <li>Prepare and      present project proposals, including cost estimates and schedules.<\/li>\n<\/ul>\n<p><strong>Execution and Supervision:<\/strong><\/p>\n<ul>\n <li>Manage and      oversee along-side project superintendent to ensure project specifications      and quality standards are met.<\/li>\n <li>Manage and      oversee along-side project superintendent to ensure field personnel follow      plans and safety guidelines.<\/li>\n <li>Schedule and      conduct regular site meetings to track progress, address issues, and communicate      with the project team.<\/li>\n<\/ul>\n<p><strong>Budget and Financial Management:<\/strong><\/p>\n<ul>\n <li>Monitor project      expenses and manage budgets to avoid cost overruns.<\/li>\n <li>Approve and      process invoices, purchase orders, and subcontractor payments.<\/li>\n <li>Prepare and      present regular financial reports to senior management.<\/li>\n<\/ul>\n<p><strong>Risk Management and Problem Resolution:<\/strong><\/p>\n<ul>\n <li>Identify      potential risks and develop mitigation plans to minimize impact on project      delivery.<\/li>\n <li>Resolve      conflicts and issues that arise during the construction process, including      client concerns, subcontractor disputes, and design challenges.<\/li>\n<\/ul>\n<p><strong>Quality and Safety Compliance:<\/strong><\/p>\n<ul>\n <li>Ensure all work      complies with local, state, and federal regulations, including      environmental standards.<\/li>\n <li>Implement and      enforce site-specific safety protocols to ensure a safe working      environment.<\/li>\n <li>Conduct regular      site inspections and audits to ensure compliance with quality and safety      standards.<\/li>\n<\/ul>\n<p><strong>Documentation and Reporting:<\/strong><\/p>\n<ul>\n <li>Maintain      comprehensive project documentation, including contracts, change orders,      schedules, and correspondence.<\/li>\n <li>Prepare and      submit regular progress reports to clients and senior management.<\/li>\n <li>Ensure all      project closeout documents are completed, including punch lists and      warranty information.<\/li>\n<\/ul>\n<p><strong>Qualifications:<\/strong><\/p>\n<p><strong>Education and Experience:<\/strong><\/p>\n<ul>\n <li>Bachelor\u2019s      degree in Construction Management, Civil Engineering, or a related field      preferred.<\/li>\n <li>Minimum of 5      years of experience in construction project management, with a focus on      sitework and civil projects.<\/li>\n <li>Proven track      record of successfully managing multiple large-scale construction      projects.<\/li>\n<\/ul>\n<p><strong>Skills and Competencies:<\/strong><\/p>\n<ul>\n <li>Strong      understanding of sitework, grading, excavation, utilities, and related      construction activities.<\/li>\n <li>Excellent      project management skills, including scheduling, budgeting, and resource      allocation.<\/li>\n <li>Proficient in      construction management software (e.g., Procore, Primavera, Microsoft      Project).<\/li>\n <li>Exceptional      communication and interpersonal skills to effectively liaise with clients,      subcontractors, and team members.<\/li>\n <li>Strong      problem-solving abilities and attention to detail.<\/li>\n<\/ul>\n<p><strong>Certifications:<\/strong><\/p>\n<ul>\n <li>Project      Management Professional (PMP) certification is a plus.<\/li>\n <li>OSHA Safety      Certification is preferred.<\/li>\n<\/ul>\n<p><strong>Work Environment:<\/strong><\/p>\n<ul>\n <li>The role      requires frequent visits to construction sites, which may involve exposure      to varying weather conditions and physical hazards.<\/li>\n <li>Occasional      travel may be required for meetings and site inspections.<\/li>\n<\/ul>","post_title":"Civil Sitework Project Manager","post_link":"https:\/\/turnerstaffing.com\/position\/civil-sitework-project-manager\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Senior","%location_country%":"United States","%location_city%":"Atlanta","%location_state_id%":"GA","%location_state_name%":"Georgia","%location_city_state%":"Atlanta, GA","%education%":"Unspecified","%department%":"","%description%":"<p><strong>Job Summary:<\/strong><\/p>\n<p>The Project Manager for our client is responsible for planning, coordinating, and overseeing all phases of sitework construction projects. This includes managing resources, schedules, financials, and adhering to quality and safety standards. The Project Manager ensures that the project is completed on time, within budget, and to the satisfaction of the client.<\/p>\n<p><strong>Key Responsibilities:<\/strong><\/p>\n<p><strong>Project Planning and Coordination:<\/strong><\/p>\n<ul>\n <li>Develop      comprehensive project plans that include timelines, resources, and      budgets.<\/li>\n <li>Coordinate with      clients, architects, engineers, and other stakeholders to define project      scope and objectives.<\/li>\n <li>Prepare and      present project proposals, including cost estimates and schedules.<\/li>\n<\/ul>\n<p><strong>Execution and Supervision:<\/strong><\/p>\n<ul>\n <li>Manage and      oversee along-side project superintendent to ensure project specifications      and quality standards are met.<\/li>\n <li>Manage and      oversee along-side project superintendent to ensure field personnel follow      plans and safety guidelines.<\/li>\n <li>Schedule and      conduct regular site meetings to track progress, address issues, and communicate      with the project team.<\/li>\n<\/ul>\n<p><strong>Budget and Financial Management:<\/strong><\/p>\n<ul>\n <li>Monitor project      expenses and manage budgets to avoid cost overruns.<\/li>\n <li>Approve and      process invoices, purchase orders, and subcontractor payments.<\/li>\n <li>Prepare and      present regular financial reports to senior management.<\/li>\n<\/ul>\n<p><strong>Risk Management and Problem Resolution:<\/strong><\/p>\n<ul>\n <li>Identify      potential risks and develop mitigation plans to minimize impact on project      delivery.<\/li>\n <li>Resolve      conflicts and issues that arise during the construction process, including      client concerns, subcontractor disputes, and design challenges.<\/li>\n<\/ul>\n<p><strong>Quality and Safety Compliance:<\/strong><\/p>\n<ul>\n <li>Ensure all work      complies with local, state, and federal regulations, including      environmental standards.<\/li>\n <li>Implement and      enforce site-specific safety protocols to ensure a safe working      environment.<\/li>\n <li>Conduct regular      site inspections and audits to ensure compliance with quality and safety      standards.<\/li>\n<\/ul>\n<p><strong>Documentation and Reporting:<\/strong><\/p>\n<ul>\n <li>Maintain      comprehensive project documentation, including contracts, change orders,      schedules, and correspondence.<\/li>\n <li>Prepare and      submit regular progress reports to clients and senior management.<\/li>\n <li>Ensure all      project closeout documents are completed, including punch lists and      warranty information.<\/li>\n<\/ul>\n<p><strong>Qualifications:<\/strong><\/p>\n<p><strong>Education and Experience:<\/strong><\/p>\n<ul>\n <li>Bachelor\u2019s      degree in Construction Management, Civil Engineering, or a related field      preferred.<\/li>\n <li>Minimum of 5      years of experience in construction project management, with a focus on      sitework and civil projects.<\/li>\n <li>Proven track      record of successfully managing multiple large-scale construction      projects.<\/li>\n<\/ul>\n<p><strong>Skills and Competencies:<\/strong><\/p>\n<ul>\n <li>Strong      understanding of sitework, grading, excavation, utilities, and related      construction activities.<\/li>\n <li>Excellent      project management skills, including scheduling, budgeting, and resource      allocation.<\/li>\n <li>Proficient in      construction management software (e.g., Procore, Primavera, Microsoft      Project).<\/li>\n <li>Exceptional      communication and interpersonal skills to effectively liaise with clients,      subcontractors, and team members.<\/li>\n <li>Strong      problem-solving abilities and attention to detail.<\/li>\n<\/ul>\n<p><strong>Certifications:<\/strong><\/p>\n<ul>\n <li>Project      Management Professional (PMP) certification is a plus.<\/li>\n <li>OSHA Safety      Certification is preferred.<\/li>\n<\/ul>\n<p><strong>Work Environment:<\/strong><\/p>\n<ul>\n <li>The role      requires frequent visits to construction sites, which may involve exposure      to varying weather conditions and physical hazards.<\/li>\n <li>Occasional      travel may be required for meetings and site inspections.<\/li>\n<\/ul>","%category%":"Management","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/d218fb337a18-civil-sitework-project-manager","%breezy_id%":"d218fb337a18","%breezy_friendly_id%":"d218fb337a18-civil-sitework-project-manager","%breezy_created_date%":"2025-06-26T15:35:28.170Z","%breezy_updated_date%":"2025-06-26T15:37:56.425Z","%_wpgmp_location_city%":"Atlanta","%_wpgmp_location_state%":"GA","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Atlanta, GA, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"33.7501275","%_wpgmp_metabox_longitude%":"-84.3885209","%rank_math_internal_links_processed%":"1"}},"id":2577,"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-2\/\" 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-2\/","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-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%":"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\/6ce59a92701e-heavy-equipment-operator","%breezy_id%":"6ce59a92701e","%breezy_friendly_id%":"6ce59a92701e-heavy-equipment-operator","%breezy_created_date%":"2024-05-17T17:39:02.612Z","%breezy_updated_date%":"2025-07-29T15:51:07.865Z","%_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":2576,"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":"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\/","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%":"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\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-07-29T15:51:19.986Z","%_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":2573,"infowindow_disable":false},{"source":"post","title":"CDL Driver- Ready Mix Trucks","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    CDL Driver- Ready Mix Trucks\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Position Overview: We are currently seeking a dependable and safety-focused Class B CDL Driver to join our team in Amboy,&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/cdl-driver-ready-mix-trucks\/\" name=\"CDL Driver- Ready Mix Trucks\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Position Overview: We are currently seeking a dependable and safety-focused Class B CDL Driver to join our team in Amboy,&hellip;","address":"Amboy, IN, USA","location":{"lat":"40.6012074","city":"Amboy","state":"IN","country":"United States","lng":"-85.929253","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/cdl-driver-ready-mix-trucks\/","zoom":19,"extra_fields":{"post_excerpt":"Position Overview: We are currently seeking a dependable and safety-focused Class B CDL Driver to join our team in Amboy,&hellip;","post_content":"<h3><strong>Position Overview:<\/strong><\/h3>\n<p>We are currently seeking a dependable and safety-focused <strong>Class B CDL Driver<\/strong> to join our team in <strong>Amboy, Indiana<\/strong>. This position involves operating a ready-mix concrete truck to deliver concrete to various residential, commercial, and industrial project sites. As a driver, you will be a key part of our operation, ensuring timely and professional delivery while maintaining high standards for safety, customer service, and equipment care.<\/p>\n<h3><strong>Key Responsibilities:<\/strong><\/h3>\n<ul>\n<li>\n<p>Safely operate a Class B ready-mix concrete truck in accordance with DOT and company regulations.<\/p>\n<\/li>\n<li>\n<p>Deliver ready-mix concrete to customer job sites within a specified service area.<\/p>\n<\/li>\n<li>\n<p>Communicate with dispatch, plant personnel, and customers to ensure accurate and timely deliveries.<\/p>\n<\/li>\n<li>\n<p>Perform pre-trip and post-trip vehicle inspections and document findings.<\/p>\n<\/li>\n<li>\n<p>Maintain cleanliness and general upkeep of the truck and equipment.<\/p>\n<\/li>\n<li>\n<p>Adjust chutes, operate controls, and assist with concrete placement as needed on job sites.<\/p>\n<\/li>\n<li>\n<p>Follow all safety guidelines, including wearing required PPE and participating in safety meetings\/training.<\/p>\n<\/li>\n<li>\n<p>Maintain accurate delivery tickets and logs as required.<\/p>\n<\/li>\n<\/ul>\n<h3><strong>Qualifications:<\/strong><\/h3>\n<ul>\n<li>\n<p>Valid <strong>Class B Commercial Driver\u2019s License (CDL)<\/strong> with air brake endorsement (Class A is a plus but not required).<\/p>\n<\/li>\n<li>\n<p>Minimum 1 year of commercial driving experience preferred; experience driving ready-mix or similar trucks is a plus.<\/p>\n<\/li>\n<li>\n<p>Clean driving record with a strong safety history.<\/p>\n<\/li>\n<li>\n<p>Ability to lift, carry, and maneuver heavy equipment and materials (up to 50 lbs).<\/p>\n<\/li>\n<li>\n<p>Familiarity with local roads and construction sites in and around Amboy, Indiana is a plus.<\/p>\n<\/li>\n<li>\n<p>Must pass DOT drug screen and physical.<\/p>\n<\/li>\n<\/ul>\n<h3><strong>Skills &amp; Attributes:<\/strong><\/h3>\n<ul>\n<li>\n<p>Strong customer service and communication skills.<\/p>\n<\/li>\n<li>\n<p>Dependable, punctual, and team-oriented.<\/p>\n<\/li>\n<li>\n<p>Self-motivated with attention to detail and accuracy.<\/p>\n<\/li>\n<li>\n<p>Ability to work in a fast-paced environment and adapt to changing schedules or weather conditions.<\/p>\n<\/li>\n<\/ul>\n<h3><strong>Work Environment:<\/strong><\/h3>\n<ul>\n<li>\n<p>Outdoor work in all weather conditions.<\/p>\n<\/li>\n<li>\n<p>Driving and operating trucks on construction sites, public roads, and plant facilities.<\/p>\n<\/li>\n<li>\n<p>Schedule may include early mornings, overtime, weekends, and occasional holidays depending on demand.<\/p><\/li><\/ul>","post_title":"CDL Driver- Ready Mix Trucks","post_link":"https:\/\/turnerstaffing.com\/position\/cdl-driver-ready-mix-trucks\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Mid Level","%location_country%":"United States","%location_city%":"Amboy","%location_state_id%":"IN","%location_state_name%":"Indiana","%location_city_state%":"Amboy, IN","%education%":"Unspecified","%department%":"","%description%":"<h3><strong>Position Overview:<\/strong><\/h3>\n<p>We are currently seeking a dependable and safety-focused <strong>Class B CDL Driver<\/strong> to join our team in <strong>Amboy, Indiana<\/strong>. This position involves operating a ready-mix concrete truck to deliver concrete to various residential, commercial, and industrial project sites. As a driver, you will be a key part of our operation, ensuring timely and professional delivery while maintaining high standards for safety, customer service, and equipment care.<\/p>\n<h3><strong>Key Responsibilities:<\/strong><\/h3>\n<ul>\n<li>\n<p>Safely operate a Class B ready-mix concrete truck in accordance with DOT and company regulations.<\/p>\n<\/li>\n<li>\n<p>Deliver ready-mix concrete to customer job sites within a specified service area.<\/p>\n<\/li>\n<li>\n<p>Communicate with dispatch, plant personnel, and customers to ensure accurate and timely deliveries.<\/p>\n<\/li>\n<li>\n<p>Perform pre-trip and post-trip vehicle inspections and document findings.<\/p>\n<\/li>\n<li>\n<p>Maintain cleanliness and general upkeep of the truck and equipment.<\/p>\n<\/li>\n<li>\n<p>Adjust chutes, operate controls, and assist with concrete placement as needed on job sites.<\/p>\n<\/li>\n<li>\n<p>Follow all safety guidelines, including wearing required PPE and participating in safety meetings\/training.<\/p>\n<\/li>\n<li>\n<p>Maintain accurate delivery tickets and logs as required.<\/p>\n<\/li>\n<\/ul>\n<h3><strong>Qualifications:<\/strong><\/h3>\n<ul>\n<li>\n<p>Valid <strong>Class B Commercial Driver\u2019s License (CDL)<\/strong> with air brake endorsement (Class A is a plus but not required).<\/p>\n<\/li>\n<li>\n<p>Minimum 1 year of commercial driving experience preferred; experience driving ready-mix or similar trucks is a plus.<\/p>\n<\/li>\n<li>\n<p>Clean driving record with a strong safety history.<\/p>\n<\/li>\n<li>\n<p>Ability to lift, carry, and maneuver heavy equipment and materials (up to 50 lbs).<\/p>\n<\/li>\n<li>\n<p>Familiarity with local roads and construction sites in and around Amboy, Indiana is a plus.<\/p>\n<\/li>\n<li>\n<p>Must pass DOT drug screen and physical.<\/p>\n<\/li>\n<\/ul>\n<h3><strong>Skills &amp; Attributes:<\/strong><\/h3>\n<ul>\n<li>\n<p>Strong customer service and communication skills.<\/p>\n<\/li>\n<li>\n<p>Dependable, punctual, and team-oriented.<\/p>\n<\/li>\n<li>\n<p>Self-motivated with attention to detail and accuracy.<\/p>\n<\/li>\n<li>\n<p>Ability to work in a fast-paced environment and adapt to changing schedules or weather conditions.<\/p>\n<\/li>\n<\/ul>\n<h3><strong>Work Environment:<\/strong><\/h3>\n<ul>\n<li>\n<p>Outdoor work in all weather conditions.<\/p>\n<\/li>\n<li>\n<p>Driving and operating trucks on construction sites, public roads, and plant facilities.<\/p>\n<\/li>\n<li>\n<p>Schedule may include early mornings, overtime, weekends, and occasional holidays depending on demand.<\/p><\/li><\/ul>","%category%":"Operations","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/1f9495a5bb39-cdl-driver-ready-mix-trucks","%breezy_id%":"1f9495a5bb39","%breezy_friendly_id%":"1f9495a5bb39-cdl-driver-ready-mix-trucks","%breezy_created_date%":"2025-06-23T16:56:15.559Z","%breezy_updated_date%":"2025-06-23T16:57:10.220Z","%_wpgmp_location_city%":"Amboy","%_wpgmp_location_state%":"IN","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Amboy, IN, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"40.6012074","%_wpgmp_metabox_longitude%":"-85.929253","%rank_math_internal_links_processed%":"1"}},"id":2569,"infowindow_disable":false},{"source":"post","title":"CDL Driver- Ready Mix Trucks","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    CDL Driver- Ready Mix Trucks\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Position Overview: We are currently seeking a dependable and safety-focused Class B CDL Driver to join our team in Argos,&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/cdl-driver-ready-mix-trucks-2\/\" name=\"CDL Driver- Ready Mix Trucks\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Position Overview: We are currently seeking a dependable and safety-focused Class B CDL Driver to join our team in Argos,&hellip;","address":"Argos, IN, USA","location":{"lat":"41.2376688","city":"Argos","state":"IN","country":"United States","lng":"-86.2539519","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/cdl-driver-ready-mix-trucks-2\/","zoom":19,"extra_fields":{"post_excerpt":"Position Overview: We are currently seeking a dependable and safety-focused Class B CDL Driver to join our team in Argos,&hellip;","post_content":"<h3><strong>Position Overview:<\/strong><\/h3>\n<p>We are currently seeking a dependable and safety-focused <strong>Class B CDL Driver<\/strong> to join our team in <strong>Argos, Indiana<\/strong>. This position involves operating a ready-mix concrete truck to deliver concrete to various residential, commercial, and industrial project sites. As a driver, you will be a key part of our operation, ensuring timely and professional delivery while maintaining high standards for safety, customer service, and equipment care.<\/p>\n<h3><strong>Key Responsibilities:<\/strong><\/h3>\n<ul>\n<li>\n<p>Safely operate a Class B ready-mix concrete truck in accordance with DOT and company regulations.<\/p>\n<\/li>\n<li>\n<p>Deliver ready-mix concrete to customer job sites within a specified service area.<\/p>\n<\/li>\n<li>\n<p>Communicate with dispatch, plant personnel, and customers to ensure accurate and timely deliveries.<\/p>\n<\/li>\n<li>\n<p>Perform pre-trip and post-trip vehicle inspections and document findings.<\/p>\n<\/li>\n<li>\n<p>Maintain cleanliness and general upkeep of the truck and equipment.<\/p>\n<\/li>\n<li>\n<p>Adjust chutes, operate controls, and assist with concrete placement as needed on job sites.<\/p>\n<\/li>\n<li>\n<p>Follow all safety guidelines, including wearing required PPE and participating in safety meetings\/training.<\/p>\n<\/li>\n<li>\n<p>Maintain accurate delivery tickets and logs as required.<\/p>\n<\/li>\n<\/ul>\n<h3><strong>Qualifications:<\/strong><\/h3>\n<ul>\n<li>\n<p>Valid <strong>Class B Commercial Driver\u2019s License (CDL)<\/strong> with air brake endorsement (Class A is a plus but not required).<\/p>\n<\/li>\n<li>\n<p>Minimum 1 year of commercial driving experience preferred; experience driving ready-mix or similar trucks is a plus.<\/p>\n<\/li>\n<li>\n<p>Clean driving record with a strong safety history.<\/p>\n<\/li>\n<li>\n<p>Ability to lift, carry, and maneuver heavy equipment and materials (up to 50 lbs).<\/p>\n<\/li>\n<li>\n<p>Familiarity with local roads and construction sites in and around Argos, Indiana is a plus.<\/p>\n<\/li>\n<li>\n<p>Must pass DOT drug screen and physical.<\/p>\n<\/li>\n<\/ul>\n<h3><strong>Skills &amp; Attributes:<\/strong><\/h3>\n<ul>\n<li>\n<p>Strong customer service and communication skills.<\/p>\n<\/li>\n<li>\n<p>Dependable, punctual, and team-oriented.<\/p>\n<\/li>\n<li>\n<p>Self-motivated with attention to detail and accuracy.<\/p>\n<\/li>\n<li>\n<p>Ability to work in a fast-paced environment and adapt to changing schedules or weather conditions.<\/p>\n<\/li>\n<\/ul>\n<h3><strong>Work Environment:<\/strong><\/h3>\n<ul>\n<li>\n<p>Outdoor work in all weather conditions.<\/p>\n<\/li>\n<li>\n<p>Driving and operating trucks on construction sites, public roads, and plant facilities.<\/p>\n<\/li>\n<li>\n<p>Schedule may include early mornings, overtime, weekends, and occasional holidays depending on demand.<\/p><\/li><\/ul>","post_title":"CDL Driver- Ready Mix Trucks","post_link":"https:\/\/turnerstaffing.com\/position\/cdl-driver-ready-mix-trucks-2\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Mid Level","%location_country%":"United States","%location_city%":"Argos","%location_state_id%":"IN","%location_state_name%":"Indiana","%location_city_state%":"Argos, IN","%education%":"Unspecified","%department%":"","%description%":"<h3><strong>Position Overview:<\/strong><\/h3>\n<p>We are currently seeking a dependable and safety-focused <strong>Class B CDL Driver<\/strong> to join our team in <strong>Argos, Indiana<\/strong>. This position involves operating a ready-mix concrete truck to deliver concrete to various residential, commercial, and industrial project sites. As a driver, you will be a key part of our operation, ensuring timely and professional delivery while maintaining high standards for safety, customer service, and equipment care.<\/p>\n<h3><strong>Key Responsibilities:<\/strong><\/h3>\n<ul>\n<li>\n<p>Safely operate a Class B ready-mix concrete truck in accordance with DOT and company regulations.<\/p>\n<\/li>\n<li>\n<p>Deliver ready-mix concrete to customer job sites within a specified service area.<\/p>\n<\/li>\n<li>\n<p>Communicate with dispatch, plant personnel, and customers to ensure accurate and timely deliveries.<\/p>\n<\/li>\n<li>\n<p>Perform pre-trip and post-trip vehicle inspections and document findings.<\/p>\n<\/li>\n<li>\n<p>Maintain cleanliness and general upkeep of the truck and equipment.<\/p>\n<\/li>\n<li>\n<p>Adjust chutes, operate controls, and assist with concrete placement as needed on job sites.<\/p>\n<\/li>\n<li>\n<p>Follow all safety guidelines, including wearing required PPE and participating in safety meetings\/training.<\/p>\n<\/li>\n<li>\n<p>Maintain accurate delivery tickets and logs as required.<\/p>\n<\/li>\n<\/ul>\n<h3><strong>Qualifications:<\/strong><\/h3>\n<ul>\n<li>\n<p>Valid <strong>Class B Commercial Driver\u2019s License (CDL)<\/strong> with air brake endorsement (Class A is a plus but not required).<\/p>\n<\/li>\n<li>\n<p>Minimum 1 year of commercial driving experience preferred; experience driving ready-mix or similar trucks is a plus.<\/p>\n<\/li>\n<li>\n<p>Clean driving record with a strong safety history.<\/p>\n<\/li>\n<li>\n<p>Ability to lift, carry, and maneuver heavy equipment and materials (up to 50 lbs).<\/p>\n<\/li>\n<li>\n<p>Familiarity with local roads and construction sites in and around Argos, Indiana is a plus.<\/p>\n<\/li>\n<li>\n<p>Must pass DOT drug screen and physical.<\/p>\n<\/li>\n<\/ul>\n<h3><strong>Skills &amp; Attributes:<\/strong><\/h3>\n<ul>\n<li>\n<p>Strong customer service and communication skills.<\/p>\n<\/li>\n<li>\n<p>Dependable, punctual, and team-oriented.<\/p>\n<\/li>\n<li>\n<p>Self-motivated with attention to detail and accuracy.<\/p>\n<\/li>\n<li>\n<p>Ability to work in a fast-paced environment and adapt to changing schedules or weather conditions.<\/p>\n<\/li>\n<\/ul>\n<h3><strong>Work Environment:<\/strong><\/h3>\n<ul>\n<li>\n<p>Outdoor work in all weather conditions.<\/p>\n<\/li>\n<li>\n<p>Driving and operating trucks on construction sites, public roads, and plant facilities.<\/p>\n<\/li>\n<li>\n<p>Schedule may include early mornings, overtime, weekends, and occasional holidays depending on demand.<\/p><\/li><\/ul>","%category%":"Operations","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/4c2181dacd56-cdl-driver-ready-mix-trucks","%breezy_id%":"4c2181dacd56","%breezy_friendly_id%":"4c2181dacd56-cdl-driver-ready-mix-trucks","%breezy_created_date%":"2025-06-23T17:22:48.887Z","%breezy_updated_date%":"2025-06-23T17:24:16.467Z","%_wpgmp_location_city%":"Argos","%_wpgmp_location_state%":"IN","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Argos, IN, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"41.2376688","%_wpgmp_metabox_longitude%":"-86.2539519","%rank_math_internal_links_processed%":"1"}},"id":2570,"infowindow_disable":false},{"source":"post","title":"Instrument Technician","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Instrument Technician\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Job Description Instrument Technician (Calibration) Tech \u2013 Engineering The Instrument Tech will have a key role responsible for calibration activities&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/instrument-technician\/\" name=\"Instrument Technician\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Job Description Instrument Technician (Calibration) Tech \u2013 Engineering The Instrument Tech will have a key role responsible for calibration activities&hellip;","address":"Indianapolis, IN, USA","location":{"lat":"39.76909","city":"Indianapolis","state":"IN","country":"United States","lng":"-86.158018","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/instrument-technician\/","zoom":19,"extra_fields":{"post_excerpt":"Job Description Instrument Technician (Calibration) Tech \u2013 Engineering The Instrument Tech will have a key role responsible for calibration activities&hellip;","post_content":"<p><strong>Job Description <\/strong><\/p>\n<p><strong><u>Instrument Technician (Calibration) Tech \u2013 Engineering<\/u><\/strong><\/p>\n<p>The Instrument Tech will have a key role responsible for calibration activities to maintain assets in compliance with cGMP. The technician will be, at a minimum, responsible for the following:<\/p>\n<ul>\n <ul>\n  <li>Servicing,       troubleshooting, and maintaining instrumentation that is part of: process       utilities, grey utilities, critical HVAC systems, process equipment,       process systems, cleaning equipment and equipment preparation systems.<\/li>\n  <li>Know,       execute and improve instrument configurations and calibrations according       to local owner job plans and procedures.<\/li>\n  <li>Display       good documentation practices (paper and electronic based documentation)<\/li>\n  <li>Support       start-up and commissioning of corporate and local capital projects<\/li>\n <\/ul>\n<\/ul>\n<p><strong><u>Key Responsibilities<\/u><\/strong><\/p>\n<p><strong>&nbsp;Startup:<\/strong><\/p>\n<ul>\n <ul>\n  <li>Support       a safety-first, and quality driven maintenance team.<\/li>\n  <li>Ability       to respond quickly and proactively to changing priorities within a       reasonable timeframe.<\/li>\n  <li>Maintain       Secondary calibration standards.<\/li>\n  <li>Cross       functionally collaboration with Operations, Utilities, Laboratories.<\/li>\n  <li>Follow       maintenance procedures such as Lockout\/Tagout (LOTO), Job Hazard Analysis       (JHA), and Computerized Maintenance Management System (CMMS) work plans.<\/li>\n  <li>Support       C&amp;Q activities, including but not limited to, initial calibrations,       shakedowns, initial\/operational verification, and\/or equipment       qualification.<\/li>\n  <li>Perform       initial calibrations of instruments.<\/li>\n  <li>Perform       preventive and corrective maintenance and calibration on Process       Instrumentation, Temperature, Pressure, Flow. Level and Automatic Control       Valves, pH, conductivity\/resistivity, <\/li>\n  <li>Troubleshoot       and diagnose Process Instrumentation Equipment problems and make       appropriate repairs to minimize downtime.<\/li>\n  <li>Perform       modifications and new installations of process instrumentation.<\/li>\n  <li>Ability       to read P &amp; ID drawings and schematics.<\/li>\n  <li>High       attention to details especially in GMP documentation.<\/li>\n <\/ul>\n<\/ul>\n<p><strong>Post Startup:<\/strong><\/p>\n<ul>\n <ul>\n  <li>Support       site instrumentation and system change controls, including but not       limited, capital projects, site process improvements, C&amp;Q activities,       calibrations, shakedowns, initial\/operational verification, and\/or       equipment qualification.<\/li>\n  <li>Perform       preventive and corrective maintenance on Process Instrumentation,       Temperature, Pressure, Flow and Automatic Control Valves<\/li>\n  <li>Ensure       ongoing continuous maintenance system improvements.<\/li>\n  <li>Support       communications between Operation shifts, Maintenance, Engineering,       Automation, and site customers to keep them informed of any issues that       could affect them.<\/li>\n  <li>Identify       and implement \u201cHuman Error Prevention\u201d opportunities.<\/li>\n  <li>Use       basic GMARS functionality daily.<\/li>\n  <li>Use       of GMARS closing notes using work order codes daily<\/li>\n  <li>Ability       to use Microsoft Office tools.<\/li>\n <\/ul>\n<\/ul>\n<p><strong>People Management: <\/strong><\/p>\n<ul>\n <ul>\n  <li>Ensure       the company values, standards, and polices are communicated to and       modelled within the team.<\/li>\n  <li>Ensure       on-going learning and team reflection.<\/li>\n  <li>Identify       and implement changes to work practices to optimize team efficiency.<\/li>\n  <li>Support       all safety practices and encourage others to do the same.&nbsp;&nbsp; Stop work if unsafe conditions are       found.<\/li>\n <\/ul>\n<\/ul>\n<p><strong><u>Basic Qualifications<\/u><\/strong><\/p>\n<ul>\n <ul>\n  <li>Education:        High School Diploma (preferred associate degree in Electronics)<\/li>\n  <li>Experience:       Minimum of two years of applied electronics and\/or system maintenance       experience<\/li>\n <\/ul>\n<\/ul>\n<p><strong><u>Shift Hours<\/u><\/strong><\/p>\n<ul>\n <ul>\n  <li>This       position is on site Monday-Friday. &nbsp;&nbsp;Some overtime, or non-dayshifts may be       required, but will be scheduled and confirmed ahead of time<\/li>\n  <li>Unscheduled       overtime will be held to a minimum, but may be necessary in the event of       critical failures.<\/li>\n <\/ul>\n<\/ul>\n<p><strong><u>Additional Skills\/Preferences<\/u><\/strong><\/p>\n<ul>\n <ul>\n  <li>Pressure,       Flow, Temperature as previous experience.<\/li>\n  <li>pH,       Conductivity, Resistivity, as a plus.<\/li>\n  <li>Lab       instrumentation, Incubators, HPLC, <\/li>\n  <li>Familiar       with maintenance CMMS, Maximo<\/li>\n  <li>Manufacturing       experience  <\/li>\n  <li>Knowledgeable       of pharmaceutical operations and processes or other GMP practices<\/li>\n  <li>Physical       requirements<\/li>\n  <ul>\n   <li>Ability        to lift 40 lbs.<\/li>\n   <li>Awkward        positions, cramped quarters, ladders, scaffoldings, and lifts will be        required at times.<\/li>\n   <li>Overtime        may be required pending work demands.<\/li>\n   <li>Work        may occur in a wide range of temperature conditions<\/li>\n  <\/ul>\n <\/ul>\n<\/ul>","post_title":"Instrument Technician","post_link":"https:\/\/turnerstaffing.com\/position\/instrument-technician\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"","%location_country%":"United States","%location_city%":"Indianapolis","%location_state_id%":"IN","%location_state_name%":"Indiana","%location_city_state%":"Indianapolis, IN","%education%":"","%department%":"","%description%":"<p><strong>Job Description <\/strong><\/p>\n<p><strong><u>Instrument Technician (Calibration) Tech \u2013 Engineering<\/u><\/strong><\/p>\n<p>The Instrument Tech will have a key role responsible for calibration activities to maintain assets in compliance with cGMP. The technician will be, at a minimum, responsible for the following:<\/p>\n<ul>\n <ul>\n  <li>Servicing,       troubleshooting, and maintaining instrumentation that is part of: process       utilities, grey utilities, critical HVAC systems, process equipment,       process systems, cleaning equipment and equipment preparation systems.<\/li>\n  <li>Know,       execute and improve instrument configurations and calibrations according       to local owner job plans and procedures.<\/li>\n  <li>Display       good documentation practices (paper and electronic based documentation)<\/li>\n  <li>Support       start-up and commissioning of corporate and local capital projects<\/li>\n <\/ul>\n<\/ul>\n<p><strong><u>Key Responsibilities<\/u><\/strong><\/p>\n<p><strong>&nbsp;Startup:<\/strong><\/p>\n<ul>\n <ul>\n  <li>Support       a safety-first, and quality driven maintenance team.<\/li>\n  <li>Ability       to respond quickly and proactively to changing priorities within a       reasonable timeframe.<\/li>\n  <li>Maintain       Secondary calibration standards.<\/li>\n  <li>Cross       functionally collaboration with Operations, Utilities, Laboratories.<\/li>\n  <li>Follow       maintenance procedures such as Lockout\/Tagout (LOTO), Job Hazard Analysis       (JHA), and Computerized Maintenance Management System (CMMS) work plans.<\/li>\n  <li>Support       C&amp;Q activities, including but not limited to, initial calibrations,       shakedowns, initial\/operational verification, and\/or equipment       qualification.<\/li>\n  <li>Perform       initial calibrations of instruments.<\/li>\n  <li>Perform       preventive and corrective maintenance and calibration on Process       Instrumentation, Temperature, Pressure, Flow. Level and Automatic Control       Valves, pH, conductivity\/resistivity, <\/li>\n  <li>Troubleshoot       and diagnose Process Instrumentation Equipment problems and make       appropriate repairs to minimize downtime.<\/li>\n  <li>Perform       modifications and new installations of process instrumentation.<\/li>\n  <li>Ability       to read P &amp; ID drawings and schematics.<\/li>\n  <li>High       attention to details especially in GMP documentation.<\/li>\n <\/ul>\n<\/ul>\n<p><strong>Post Startup:<\/strong><\/p>\n<ul>\n <ul>\n  <li>Support       site instrumentation and system change controls, including but not       limited, capital projects, site process improvements, C&amp;Q activities,       calibrations, shakedowns, initial\/operational verification, and\/or       equipment qualification.<\/li>\n  <li>Perform       preventive and corrective maintenance on Process Instrumentation,       Temperature, Pressure, Flow and Automatic Control Valves<\/li>\n  <li>Ensure       ongoing continuous maintenance system improvements.<\/li>\n  <li>Support       communications between Operation shifts, Maintenance, Engineering,       Automation, and site customers to keep them informed of any issues that       could affect them.<\/li>\n  <li>Identify       and implement \u201cHuman Error Prevention\u201d opportunities.<\/li>\n  <li>Use       basic GMARS functionality daily.<\/li>\n  <li>Use       of GMARS closing notes using work order codes daily<\/li>\n  <li>Ability       to use Microsoft Office tools.<\/li>\n <\/ul>\n<\/ul>\n<p><strong>People Management: <\/strong><\/p>\n<ul>\n <ul>\n  <li>Ensure       the company values, standards, and polices are communicated to and       modelled within the team.<\/li>\n  <li>Ensure       on-going learning and team reflection.<\/li>\n  <li>Identify       and implement changes to work practices to optimize team efficiency.<\/li>\n  <li>Support       all safety practices and encourage others to do the same.&nbsp;&nbsp; Stop work if unsafe conditions are       found.<\/li>\n <\/ul>\n<\/ul>\n<p><strong><u>Basic Qualifications<\/u><\/strong><\/p>\n<ul>\n <ul>\n  <li>Education:        High School Diploma (preferred associate degree in Electronics)<\/li>\n  <li>Experience:       Minimum of two years of applied electronics and\/or system maintenance       experience<\/li>\n <\/ul>\n<\/ul>\n<p><strong><u>Shift Hours<\/u><\/strong><\/p>\n<ul>\n <ul>\n  <li>This       position is on site Monday-Friday. &nbsp;&nbsp;Some overtime, or non-dayshifts may be       required, but will be scheduled and confirmed ahead of time<\/li>\n  <li>Unscheduled       overtime will be held to a minimum, but may be necessary in the event of       critical failures.<\/li>\n <\/ul>\n<\/ul>\n<p><strong><u>Additional Skills\/Preferences<\/u><\/strong><\/p>\n<ul>\n <ul>\n  <li>Pressure,       Flow, Temperature as previous experience.<\/li>\n  <li>pH,       Conductivity, Resistivity, as a plus.<\/li>\n  <li>Lab       instrumentation, Incubators, HPLC, <\/li>\n  <li>Familiar       with maintenance CMMS, Maximo<\/li>\n  <li>Manufacturing       experience  <\/li>\n  <li>Knowledgeable       of pharmaceutical operations and processes or other GMP practices<\/li>\n  <li>Physical       requirements<\/li>\n  <ul>\n   <li>Ability        to lift 40 lbs.<\/li>\n   <li>Awkward        positions, cramped quarters, ladders, scaffoldings, and lifts will be        required at times.<\/li>\n   <li>Overtime        may be required pending work demands.<\/li>\n   <li>Work        may occur in a wide range of temperature conditions<\/li>\n  <\/ul>\n <\/ul>\n<\/ul>","%category%":"","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/793bc235dd0b-instrument-technician","%breezy_id%":"793bc235dd0b","%breezy_friendly_id%":"793bc235dd0b-instrument-technician","%breezy_created_date%":"2025-06-21T02:31:07.548Z","%breezy_updated_date%":"2025-06-21T02:32:52.394Z","%_wpgmp_location_city%":"Indianapolis","%_wpgmp_location_state%":"IN","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Indianapolis, IN, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"39.76909","%_wpgmp_metabox_longitude%":"-86.158018","%rank_math_internal_links_processed%":"1"}},"id":2567,"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-07-28T20:13:26.872Z","%_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":"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 Turner Mining Group is seeking an energetic mining professionals who can leverage their&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/dozer-operator-3\/\" name=\"Dozer Operator\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Turner Mining Group \u2013 Heavy Equipment Operator Turner Mining Group is seeking an energetic mining professionals who can leverage their&hellip;","address":"Pacific, MO, USA","location":{"lat":"38.4819976","city":"Pacific","state":"MO","country":"United States","lng":"-90.7415194","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/dozer-operator-3\/","zoom":19,"extra_fields":{"post_excerpt":"Turner Mining Group \u2013 Heavy Equipment Operator Turner Mining Group is seeking an energetic mining professionals who can leverage their&hellip;","post_content":"<p><strong><u>Turner Mining Group \u2013 Heavy Equipment Operator<\/u><\/strong><br><\/p>\n\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-3\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"","%location_country%":"United States","%location_city%":"Pacific","%location_state_id%":"MO","%location_state_name%":"Missouri","%location_city_state%":"Pacific, MO","%education%":"Unspecified","%department%":"","%description%":"<p><strong><u>Turner Mining Group \u2013 Heavy Equipment Operator<\/u><\/strong><br><\/p>\n\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\/628214016e67-dozer-operator","%breezy_id%":"628214016e67","%breezy_friendly_id%":"628214016e67-dozer-operator","%breezy_created_date%":"2025-04-17T13:00:03.700Z","%breezy_updated_date%":"2025-07-29T15:50:57.545Z","%_wpgmp_location_city%":"Pacific","%_wpgmp_location_state%":"MO","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Pacific, MO, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"38.4819976","%_wpgmp_metabox_longitude%":"-90.7415194","%rank_math_internal_links_processed%":"1"}},"id":2561,"infowindow_disable":false},{"source":"post","title":"Senior Corporate Long Range Engineer","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Senior Corporate Long Range Engineer\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    The Long-Range Mining Engineer is responsible for defining the strategic direction and long-term economic value of the mining operation. This&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/senior-corporate-long-range-engineer\/\" name=\"Senior Corporate Long Range Engineer\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"The Long-Range Mining Engineer is responsible for defining the strategic direction and long-term economic value of the mining operation. This&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-corporate-long-range-engineer\/","zoom":19,"extra_fields":{"post_excerpt":"The Long-Range Mining Engineer is responsible for defining the strategic direction and long-term economic value of the mining operation. This&hellip;","post_content":"<p>The Long-Range Mining Engineer is responsible for defining the strategic direction and long-term economic value of the mining operation. This position develops and maintains the Life-of-Mine (LOM) plan, conducts pit and phase optimizations, performs trade-off studies, and builds economic models that guide capital investments and operational strategy. Reporting to the General Manager of Technical Services, this role works closely with geotechnical, geology, finance, and operations teams to ensure technical accuracy, regulatory compliance, and alignment across planning horizons.<\/p>\n<p>This role is critical to connecting the company\u2019s growth vision with a technically sound, financially optimized mine plan that supports execution at the short-, medium-, and long-term levels.<\/p>\n<p>Essential Functions:<\/p>\n<p>Develop and maintain the Life-of-Mine (LOM) plan using updated resource models, pit designs, cost inputs, and geotechnical constraints.<\/p>\n<p>Conduct pit optimizations, pushback designs, and phase sequencing based on NPV maximization and business goals.<\/p>\n<p>Define ultimate pit limits and evaluate development scenarios using Whittle, MPVS, or equivalent strategic planning tools.<\/p>\n<p>Build and validate long-term mine schedules using tools like MinePlan 3D, MPSO, and Reserve Reporting utilities.<\/p>\n<p>Develop and maintain long-range cost models, incorporating drill\/blast, haulage, pad stacking, and capital expenditure data.<\/p>\n<p>Analyze unit costs by material type and pit benches\/zones to perform cutoff grade optimization and economic phase ranking.<\/p>\n<p>Integrate geotechnical, hydrological, and geometallurgical inputs into the strategic plan to ensure safe, practical, and efficient development.<\/p>\n<p>Prepare and update haulage profiles, waste dump and leach dump designs, and infrastructure sequencing in support of long-term efficiency.<\/p>\n<p>Translate strategic models into actionable five-year plans, supporting annual budgets and rolling forecast updates.<\/p>\n<p>Conduct scenario analysis and economic trade-off studies including DCF modeling, stockpiling strategies, and pit expansion timing.<\/p>\n<p>Collaborate with the Technical Services, Geology, and Finance departments to validate assumptions and align KPIs.<\/p>\n<p>Support regulatory and stakeholder engagement through the preparation of documentation for permitting, reserve reporting (SK-1300), and business case presentations.<\/p>\n<p>Participate in strategic evaluations such as infrastructure placement, crusher relocation timing, and pit expansion logic.<\/p>\n<p>Work closely with the technical planning teams to ensure alignment between long-range plans and short- and medium-term execution.<\/p>\n<p>Contribute to business planning reviews, optimization initiatives, and site-wide strategic evaluations.<\/p>\n<p>Requirements<\/p>\n<p>Required Knowledge, Skills, and Abilities:<\/p>\n<p>Strong knowledge of open pit mine optimization, NPV modeling, and strategic pit design principles.<\/p>\n<p>Proficiency in Hexagon MinePlan 3D, including MPSO, Reserve Reporting, haulage profile development, Whittle, and industry software suites.<\/p>\n<p>Experience with Whittle or equivalent tools for economic optimization and scenario analysis.<\/p>\n<p>Familiarity with financial modeling, discounted cash flow (DCF) techniques, and strategic option evaluation.<\/p>\n<p>Knowledge of geotechnical, hydrological, and geometallurgical inputs to long-term mine design.<\/p>\n<p>Understanding of geological modeling, resource classification, and reserve conversion under S-K 1300 guidelines.<\/p>\n<p>Familiarity with leach operations, copper recovery, and material routing strategies.<\/p>\n<p>Strong skills in cost modeling and integration with financial performance indicators.<\/p>\n<p>Effective communication and reporting skills, including PowerPoint presentations and dashboard creation (e.g., Power BI).<\/p>\n<p>Ability to translate long-range scenarios into tactical frameworks that can be implemented by medium- and short-range engineers.<\/p>\n<p>Analytical mindset with the ability to balance technical precision and business objectives.<\/p>\n<p>Experience in copper mining, leach operations, and resource modeling workflows.<\/p>\n<p>Must be able to interact effectively in a multi-disciplinary team setting.<\/p>\n<p>Required Education and Experience:<\/p>\n<p>Bachelor\u2019s degree in Mining Engineering or related.<\/p>\n<p>Minimum 8 years of experience in open pit mine planning, including at least 2 years focused on long-range or strategic planning.<\/p>\n<p>Demonstrated experience with pit and phase optimization, LOM scheduling, and reserve reporting.<\/p>\n<p>English proficiency is required.<\/p>","post_title":"Senior Corporate Long Range Engineer","post_link":"https:\/\/turnerstaffing.com\/position\/senior-corporate-long-range-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 Long-Range Mining Engineer is responsible for defining the strategic direction and long-term economic value of the mining operation. This position develops and maintains the Life-of-Mine (LOM) plan, conducts pit and phase optimizations, performs trade-off studies, and builds economic models that guide capital investments and operational strategy. Reporting to the General Manager of Technical Services, this role works closely with geotechnical, geology, finance, and operations teams to ensure technical accuracy, regulatory compliance, and alignment across planning horizons.<\/p>\n<p>This role is critical to connecting the company\u2019s growth vision with a technically sound, financially optimized mine plan that supports execution at the short-, medium-, and long-term levels.<\/p>\n<p>Essential Functions:<\/p>\n<p>Develop and maintain the Life-of-Mine (LOM) plan using updated resource models, pit designs, cost inputs, and geotechnical constraints.<\/p>\n<p>Conduct pit optimizations, pushback designs, and phase sequencing based on NPV maximization and business goals.<\/p>\n<p>Define ultimate pit limits and evaluate development scenarios using Whittle, MPVS, or equivalent strategic planning tools.<\/p>\n<p>Build and validate long-term mine schedules using tools like MinePlan 3D, MPSO, and Reserve Reporting utilities.<\/p>\n<p>Develop and maintain long-range cost models, incorporating drill\/blast, haulage, pad stacking, and capital expenditure data.<\/p>\n<p>Analyze unit costs by material type and pit benches\/zones to perform cutoff grade optimization and economic phase ranking.<\/p>\n<p>Integrate geotechnical, hydrological, and geometallurgical inputs into the strategic plan to ensure safe, practical, and efficient development.<\/p>\n<p>Prepare and update haulage profiles, waste dump and leach dump designs, and infrastructure sequencing in support of long-term efficiency.<\/p>\n<p>Translate strategic models into actionable five-year plans, supporting annual budgets and rolling forecast updates.<\/p>\n<p>Conduct scenario analysis and economic trade-off studies including DCF modeling, stockpiling strategies, and pit expansion timing.<\/p>\n<p>Collaborate with the Technical Services, Geology, and Finance departments to validate assumptions and align KPIs.<\/p>\n<p>Support regulatory and stakeholder engagement through the preparation of documentation for permitting, reserve reporting (SK-1300), and business case presentations.<\/p>\n<p>Participate in strategic evaluations such as infrastructure placement, crusher relocation timing, and pit expansion logic.<\/p>\n<p>Work closely with the technical planning teams to ensure alignment between long-range plans and short- and medium-term execution.<\/p>\n<p>Contribute to business planning reviews, optimization initiatives, and site-wide strategic evaluations.<\/p>\n<p>Requirements<\/p>\n<p>Required Knowledge, Skills, and Abilities:<\/p>\n<p>Strong knowledge of open pit mine optimization, NPV modeling, and strategic pit design principles.<\/p>\n<p>Proficiency in Hexagon MinePlan 3D, including MPSO, Reserve Reporting, haulage profile development, Whittle, and industry software suites.<\/p>\n<p>Experience with Whittle or equivalent tools for economic optimization and scenario analysis.<\/p>\n<p>Familiarity with financial modeling, discounted cash flow (DCF) techniques, and strategic option evaluation.<\/p>\n<p>Knowledge of geotechnical, hydrological, and geometallurgical inputs to long-term mine design.<\/p>\n<p>Understanding of geological modeling, resource classification, and reserve conversion under S-K 1300 guidelines.<\/p>\n<p>Familiarity with leach operations, copper recovery, and material routing strategies.<\/p>\n<p>Strong skills in cost modeling and integration with financial performance indicators.<\/p>\n<p>Effective communication and reporting skills, including PowerPoint presentations and dashboard creation (e.g., Power BI).<\/p>\n<p>Ability to translate long-range scenarios into tactical frameworks that can be implemented by medium- and short-range engineers.<\/p>\n<p>Analytical mindset with the ability to balance technical precision and business objectives.<\/p>\n<p>Experience in copper mining, leach operations, and resource modeling workflows.<\/p>\n<p>Must be able to interact effectively in a multi-disciplinary team setting.<\/p>\n<p>Required Education and Experience:<\/p>\n<p>Bachelor\u2019s degree in Mining Engineering or related.<\/p>\n<p>Minimum 8 years of experience in open pit mine planning, including at least 2 years focused on long-range or strategic planning.<\/p>\n<p>Demonstrated experience with pit and phase optimization, LOM scheduling, and reserve reporting.<\/p>\n<p>English proficiency is required.<\/p>","%category%":"","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/a7a64877c135-senior-corporate-long-range-engineer","%breezy_id%":"a7a64877c135","%breezy_friendly_id%":"a7a64877c135-senior-corporate-long-range-engineer","%breezy_created_date%":"2025-06-19T21:07:57.398Z","%breezy_updated_date%":"2025-06-19T21:12:05.601Z","%_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":2559,"infowindow_disable":false},{"source":"post","title":"Excavator Operator","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Excavator Operator\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Turner Mining Group \u2013 Heavy Equipment Operator 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\/excavator-operator-2\/\" name=\"Excavator 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":"Pacific, MO, USA","location":{"lat":"38.4819976","city":"Pacific","state":"MO","country":"United States","lng":"-90.7415194","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/excavator-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\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":"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%":"Pacific","%location_state_id%":"MO","%location_state_name%":"Missouri","%location_city_state%":"Pacific, MO","%education%":"Unspecified","%department%":"","%description%":"<p><strong><u>Turner Mining Group \u2013 Heavy Equipment Operator<\/u><\/strong><br><\/p>\n\n<p>We are looking for a dynamic and talented mining Heavy Equipment Operators for our fast-growing, forward thinking mining services company headquartered in Bloomington, Indiana with our Operations team headquartered in Salt Lake City, Utah.<\/p>\n<p>Turner Mining Group is seeking an energetic mining professionals who can leverage their mining knowledge to expand upon our fast-growing business, creating best practices for equipment operations to ensure profitable operations.<\/p>\n<p><strong>You<\/strong><\/p>\n<p>You want to work for a services company that is rapidly changing the way the largest materials producers do business. You are motivated by solving problems and partnering with our clients and suppliers. You want to work with great people and enjoy being a part of a strong team. You are a knowledgeable Operator who is not afraid to jump into every detail. You want to be in a place where continuous learning and growth is the norm. You are adaptable and able to juggle multiple initiatives concurrently.<\/p>\n<p><strong>Responsibilities:<\/strong><\/p>\n<ul><li>Operating heavy equipment including loaders, scrapers, blade, excavators, dozers, haul trucks, and other pieces of heavy equipment in a production environment<\/li><li>Performing all pre-shift inspections, some basic maintenance and upkeep<\/li><li>Working with teammates on crew to maximize production while always maintaining our safety rules and regulations.<\/li><\/ul>\n<p><strong>Requirements:<\/strong><\/p>\n<ul><li>Safety oriented, awareness of everyone and everything that is around you<\/li><li>Strong work ethic<\/li><li>Willingness to learn<\/li><li>Ability to be flexible and to adapt<\/li><li>Experience with heavy equipment<\/li><li>Preferred to have MSHA training<\/li><\/ul>\n<p><strong>Benefits:<\/strong><\/p>\n<p>Turner Mining Group offers a competitive salary, an excellent work culture, career advancement opportunities. Our team offers a benefits program which includes Medical, Dental, Vision, Life, and a 401k with company match.<\/p>\n<p>At Turner Mining Group, we encourage and celebrate an inclusive environment for all employees and are proud to be an equal opportunity workplace and affirmative action employer.<\/p>","%category%":"Operations","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/356ced2b2b10-excavator-operator","%breezy_id%":"356ced2b2b10","%breezy_friendly_id%":"356ced2b2b10-excavator-operator","%breezy_created_date%":"2025-04-01T12:44:08.499Z","%breezy_updated_date%":"2025-07-14T13:09:21.520Z","%_wpgmp_location_city%":"Pacific","%_wpgmp_location_state%":"MO","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Pacific, MO, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"38.4819976","%_wpgmp_metabox_longitude%":"-90.7415194","%rank_math_internal_links_processed%":"1"}},"id":2558,"infowindow_disable":false},{"source":"post","title":"Blade Operator","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Blade Operator\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Turner Mining Group \u2013 Heavy Equipment Operator Do you love mining? Do you think differently? Are you ready to define&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/blade-operator-2\/\" name=\"Blade Operator\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Turner Mining Group \u2013 Heavy Equipment Operator Do you love mining? Do you think differently? Are you ready to define&hellip;","address":"Ludlow, VT, USA","location":{"lat":"43.3960723","city":"Ludlow","state":"VT","country":"United States","lng":"-72.7010471","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/blade-operator-2\/","zoom":19,"extra_fields":{"post_excerpt":"Turner Mining Group \u2013 Heavy Equipment Operator Do you love mining? Do you think differently? Are you ready to define&hellip;","post_content":"<p><strong><u>Turner Mining Group \u2013 Heavy Equipment Operator<\/u><\/strong><\/p>\n<p>Do you love mining? Do you think differently? Are you ready to define the future of this industry?<\/p>\n<p>We\u2019ve been waiting for you! Turner Mining Group is committed to changing the way mining companies do business. We develop our people. We partner with our clients. We believe in win, win, win.<\/p>\n<p>We are looking for a dynamic and talented mining Heavy Equipment Operators for our fast-growing, forward thinking mining services company headquartered in Bloomington, Indiana with our Operations team headquartered in Salt Lake City, Utah.<\/p>\n<p>Turner Mining Group is seeking an energetic mining professionals who can leverage their mining knowledge to expand upon our fast-growing business, creating best practices for equipment operations to ensure profitable operations.<\/p>\n<p><strong>You<\/strong><\/p>\n<p>You want to work for a services company that is rapidly changing the way the largest materials producers do business. You are motivated by solving problems and partnering with our clients and suppliers. You want to work with great people and enjoy being a part of a strong team. You are a knowledgeable Operator who is not afraid to jump into every detail. You want to be in a place where continuous learning and growth is the norm. You are adaptable and able to juggle multiple initiatives concurrently.<\/p>\n<p><strong>Responsibilities:<\/strong><\/p>\n<ul><li>Operating heavy equipment including loaders, scrapers, blade, excavators, dozers, haul trucks, and other pieces of heavy equipment in a production environment<\/li><li>Performing all pre-shift inspections, some basic maintenance and upkeep<\/li><li>Working with teammates on crew to maximize production while always maintaining our safety rules and regulations.<\/li><\/ul>\n<p><strong>Requirements:<\/strong><\/p>\n<ul><li>Safety oriented, awareness of everyone and everything that is around you<\/li><li>Strong work ethic<\/li><li>Willingness to learn<\/li><li>Ability to be flexible and to adapt<\/li><li>Experience with heavy equipment<\/li><li>Preferred to have MSHA training<\/li><\/ul>\n<p><strong>Benefits:<\/strong><\/p>\n<p>Turner Mining Group offers a competitive salary, an excellent work culture, career advancement opportunities. Our team offers a benefits program which includes Medical, Dental, Vision, Life, and a 401k with company match.<\/p>\n<p>At Turner Mining Group, we encourage and celebrate an inclusive environment for all employees and are proud to be an equal opportunity workplace and affirmative action employer.<\/p>","post_title":"Blade Operator","post_link":"https:\/\/turnerstaffing.com\/position\/blade-operator-2\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Associate","%location_country%":"United States","%location_city%":"Ludlow","%location_state_id%":"VT","%location_state_name%":"Vermont","%location_city_state%":"Ludlow, VT","%education%":"Unspecified","%department%":"Operations","%description%":"<p><strong><u>Turner Mining Group \u2013 Heavy Equipment Operator<\/u><\/strong><\/p>\n<p>Do you love mining? Do you think differently? Are you ready to define the future of this industry?<\/p>\n<p>We\u2019ve been waiting for you! Turner Mining Group is committed to changing the way mining companies do business. We develop our people. We partner with our clients. We believe in win, win, win.<\/p>\n<p>We are looking for a dynamic and talented mining Heavy Equipment Operators for our fast-growing, forward thinking mining services company headquartered in Bloomington, Indiana with our Operations team headquartered in Salt Lake City, Utah.<\/p>\n<p>Turner Mining Group is seeking an energetic mining professionals who can leverage their mining knowledge to expand upon our fast-growing business, creating best practices for equipment operations to ensure profitable operations.<\/p>\n<p><strong>You<\/strong><\/p>\n<p>You want to work for a services company that is rapidly changing the way the largest materials producers do business. You are motivated by solving problems and partnering with our clients and suppliers. You want to work with great people and enjoy being a part of a strong team. You are a knowledgeable Operator who is not afraid to jump into every detail. You want to be in a place where continuous learning and growth is the norm. You are adaptable and able to juggle multiple initiatives concurrently.<\/p>\n<p><strong>Responsibilities:<\/strong><\/p>\n<ul><li>Operating heavy equipment including loaders, scrapers, blade, excavators, dozers, haul trucks, and other pieces of heavy equipment in a production environment<\/li><li>Performing all pre-shift inspections, some basic maintenance and upkeep<\/li><li>Working with teammates on crew to maximize production while always maintaining our safety rules and regulations.<\/li><\/ul>\n<p><strong>Requirements:<\/strong><\/p>\n<ul><li>Safety oriented, awareness of everyone and everything that is around you<\/li><li>Strong work ethic<\/li><li>Willingness to learn<\/li><li>Ability to be flexible and to adapt<\/li><li>Experience with heavy equipment<\/li><li>Preferred to have MSHA training<\/li><\/ul>\n<p><strong>Benefits:<\/strong><\/p>\n<p>Turner Mining Group offers a competitive salary, an excellent work culture, career advancement opportunities. Our team offers a benefits program which includes Medical, Dental, Vision, Life, and a 401k with company match.<\/p>\n<p>At Turner Mining Group, we encourage and celebrate an inclusive environment for all employees and are proud to be an equal opportunity workplace and affirmative action employer.<\/p>","%category%":"Operations","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/797ede342858-blade-operator","%breezy_id%":"797ede342858","%breezy_friendly_id%":"797ede342858-blade-operator","%breezy_created_date%":"2025-03-26T13:32:51.997Z","%breezy_updated_date%":"2025-07-29T15:50:50.738Z","%_wpgmp_location_city%":"Ludlow","%_wpgmp_location_state%":"VT","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Ludlow, VT, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"43.3960723","%_wpgmp_metabox_longitude%":"-72.7010471","%rank_math_internal_links_processed%":"1"}},"id":2557,"infowindow_disable":false},{"source":"post","title":"Field Service Technician","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Field Service Technician\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    KEY RESPONSIBILITIES \u2022 Perform field service troubleshooting and diagnosing, timely repairs, and component installation on all makes and models of&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/field-service-technician-2\/\" name=\"Field Service Technician\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"KEY RESPONSIBILITIES \u2022 Perform field service troubleshooting and diagnosing, timely repairs, and component installation on all makes and models of&hellip;","address":"Kansas City, MO, USA","location":{"lat":"39.0997265","city":"Kansas City","state":"MO","country":"United States","lng":"-94.5785667","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/field-service-technician-2\/","zoom":19,"extra_fields":{"post_excerpt":"KEY RESPONSIBILITIES \u2022 Perform field service troubleshooting and diagnosing, timely repairs, and component installation on all makes and models of&hellip;","post_content":"<p>KEY RESPONSIBILITIES<\/p>\n<p>\u2022 Perform field service troubleshooting and diagnosing, timely repairs, and component installation on all makes and<\/p>\n<p>models of our client's&nbsp;equipment.<\/p>\n<p>\u2022 Diagnose faults or malfunctions to determine required repairs using engine diagnostic equipment such as<\/p>\n<p>computerized test equipment and calibration devices.<\/p>\n<p>\u2022 Working knowledge of reading blueprints, wiring diagrams, schematic drawings, or engineering instructions for<\/p>\n<p>assembling electronic units.<\/p>\n<p>\u2022 Test electrical units, analyze results to evaluate performance and determine need for adjustment.<\/p>\n<p>\u2022 Test mechanical products and equipment after repair or assembly to ensure proper performance and compliance<\/p>\n<p>with manufacturer's specifications.<\/p>\n<p>\u2022 Manage and maintain all aspects of the customer relationship through open communication and timely follow-up.<\/p>\n<p>\u2022 Provide customer support and education, working with users to identify needs, determine sources of problems, or<\/p>\n<p>to provide information on product use.<\/p>\n<p>\u2022 Troubleshoot issues and concerns, partnering with other departments and leadership as necessary.<\/p>\n<p>\u2022 Research, order, and maintain parts inventory for services and repairs.<\/p>\n<p>\u2022 Read and understand operating manuals, blueprints, and technical drawings.<\/p>\n<p>\u2022 Maintains condition of mobile service vehicle, parts inventory, tools, and equipment.<\/p>\n<p>\u2022 Follow all safety rules and regulations while performing work assignments and adhere to all policies and<\/p>\n<p>procedures as specified in company work rules.<\/p>\n<p>OTHER RESPONSIBILITIES<\/p>\n<p>\u2022 All other duties as assigned by supervisor\/manager<\/p>\n<p>ABILITIES<\/p>\n<p>\u2022 Demonstrates our client\u2019s values of Harmony, Fairness and Generosity.<\/p>\n<p>\u2022 Ability to travel up to 75% of the time (estimated at 3 weeks a month).<\/p>\n<p>\u2022 Strong communication skills both orally and written, at all levels of the organization.<\/p>\n<p>\u2022 General computer skills \u2013 proficiency with Word, Excel, PowerPoint, Outlook and file sharing preferred.<\/p>\n<p>\u2022 Basic mathematical skills (add\/subtract\/multiply\/divide and work with decimals and fractions).<\/p>\n<p>\u2022 Ability to read and interpret documents, including, but not limited to blueprints, operating and maintenance<\/p>\n<p>instructions and procedural manuals.<\/p>\n<p>\u2022 Capacity to manage and prioritize multiple tasks\/projects while meeting deadlines and managing time effectively.<\/p>\n<p>\u2022 Ability to exercise sound judgement and make decisions in a manner consistent with company policies, practices,<\/p>\n<p>and culture.<\/p>\n<p>\u2022 Ability to drive and accept change while being creative and forward-thinking.<\/p>\n<p>\u2022 Ability to solve practical problems and deal with a variety of concrete variables in situations where only limited<\/p>\n<p>standardization exists.<\/p>\n<p>\u2022 Ability to maintain high levels of confidentiality and trust.<\/p>\n<p>\u2022 Ability to work independently as well as in a team environment.<\/p>\n<p>\u2022 Working knowledge of hydraulics, pneumatics, diesel engines, electrical, fuel and other systems is preferred.<\/p>\n<p>\u2022 Capable of meeting and maintaining health and safety guidelines while keeping work area in a clean and orderly<\/p>\n<p>fashion.<\/p>\n<p>\u2022 Working conditions include office and professional as well as work including industrial environments as well as<\/p>\n<p>outside temperatures and all-weather conditions.<\/p>\n<p>QUALIFICATIONS<\/p>\n<p>\u2022 Two-year technical school degree in Diesel\/Heavy Equipment or related field and\/or at least three years or more<\/p>\n<p>of mechanical experience is preferred.<\/p>\n<p>\u2022 Working knowledge of hydraulics, pneumatics, diesel engines, fuel and other systems is preferred.<\/p>\n<p>\u2022 Must have the ability to obtain or carry a Class A CDL and DOT health card, with a clean driving record<\/p>\n<p>\u2022 Must have excellent communication skills, both written and verbal and the ability to establish and maintain<\/p>\n<p>effective working relationships at all levels of the organization<\/p>\n<p>\u2022 Demonstrated excellent work-ethic with self-motivation, ability to work safe with no supervision on customer job<\/p>\n<p>sites, while maintaining company and customer expectations of thoroughness and customer service<\/p>\n<p>\u2022 Ability to read and follow intermediate measurements, schematics, and technical documentation<\/p>\n<p>\u2022 Basic computer skills required using Microsoft Office Suite programs and file sharing<\/p>","post_title":"Field Service Technician","post_link":"https:\/\/turnerstaffing.com\/position\/field-service-technician-2\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Mid Level","%location_country%":"United States","%location_city%":"Kansas City","%location_state_id%":"MO","%location_state_name%":"Missouri","%location_city_state%":"Kansas City, MO","%education%":"High School or Equivalent","%department%":"","%description%":"<p>KEY RESPONSIBILITIES<\/p>\n<p>\u2022 Perform field service troubleshooting and diagnosing, timely repairs, and component installation on all makes and<\/p>\n<p>models of our client's&nbsp;equipment.<\/p>\n<p>\u2022 Diagnose faults or malfunctions to determine required repairs using engine diagnostic equipment such as<\/p>\n<p>computerized test equipment and calibration devices.<\/p>\n<p>\u2022 Working knowledge of reading blueprints, wiring diagrams, schematic drawings, or engineering instructions for<\/p>\n<p>assembling electronic units.<\/p>\n<p>\u2022 Test electrical units, analyze results to evaluate performance and determine need for adjustment.<\/p>\n<p>\u2022 Test mechanical products and equipment after repair or assembly to ensure proper performance and compliance<\/p>\n<p>with manufacturer's specifications.<\/p>\n<p>\u2022 Manage and maintain all aspects of the customer relationship through open communication and timely follow-up.<\/p>\n<p>\u2022 Provide customer support and education, working with users to identify needs, determine sources of problems, or<\/p>\n<p>to provide information on product use.<\/p>\n<p>\u2022 Troubleshoot issues and concerns, partnering with other departments and leadership as necessary.<\/p>\n<p>\u2022 Research, order, and maintain parts inventory for services and repairs.<\/p>\n<p>\u2022 Read and understand operating manuals, blueprints, and technical drawings.<\/p>\n<p>\u2022 Maintains condition of mobile service vehicle, parts inventory, tools, and equipment.<\/p>\n<p>\u2022 Follow all safety rules and regulations while performing work assignments and adhere to all policies and<\/p>\n<p>procedures as specified in company work rules.<\/p>\n<p>OTHER RESPONSIBILITIES<\/p>\n<p>\u2022 All other duties as assigned by supervisor\/manager<\/p>\n<p>ABILITIES<\/p>\n<p>\u2022 Demonstrates our client\u2019s values of Harmony, Fairness and Generosity.<\/p>\n<p>\u2022 Ability to travel up to 75% of the time (estimated at 3 weeks a month).<\/p>\n<p>\u2022 Strong communication skills both orally and written, at all levels of the organization.<\/p>\n<p>\u2022 General computer skills \u2013 proficiency with Word, Excel, PowerPoint, Outlook and file sharing preferred.<\/p>\n<p>\u2022 Basic mathematical skills (add\/subtract\/multiply\/divide and work with decimals and fractions).<\/p>\n<p>\u2022 Ability to read and interpret documents, including, but not limited to blueprints, operating and maintenance<\/p>\n<p>instructions and procedural manuals.<\/p>\n<p>\u2022 Capacity to manage and prioritize multiple tasks\/projects while meeting deadlines and managing time effectively.<\/p>\n<p>\u2022 Ability to exercise sound judgement and make decisions in a manner consistent with company policies, practices,<\/p>\n<p>and culture.<\/p>\n<p>\u2022 Ability to drive and accept change while being creative and forward-thinking.<\/p>\n<p>\u2022 Ability to solve practical problems and deal with a variety of concrete variables in situations where only limited<\/p>\n<p>standardization exists.<\/p>\n<p>\u2022 Ability to maintain high levels of confidentiality and trust.<\/p>\n<p>\u2022 Ability to work independently as well as in a team environment.<\/p>\n<p>\u2022 Working knowledge of hydraulics, pneumatics, diesel engines, electrical, fuel and other systems is preferred.<\/p>\n<p>\u2022 Capable of meeting and maintaining health and safety guidelines while keeping work area in a clean and orderly<\/p>\n<p>fashion.<\/p>\n<p>\u2022 Working conditions include office and professional as well as work including industrial environments as well as<\/p>\n<p>outside temperatures and all-weather conditions.<\/p>\n<p>QUALIFICATIONS<\/p>\n<p>\u2022 Two-year technical school degree in Diesel\/Heavy Equipment or related field and\/or at least three years or more<\/p>\n<p>of mechanical experience is preferred.<\/p>\n<p>\u2022 Working knowledge of hydraulics, pneumatics, diesel engines, fuel and other systems is preferred.<\/p>\n<p>\u2022 Must have the ability to obtain or carry a Class A CDL and DOT health card, with a clean driving record<\/p>\n<p>\u2022 Must have excellent communication skills, both written and verbal and the ability to establish and maintain<\/p>\n<p>effective working relationships at all levels of the organization<\/p>\n<p>\u2022 Demonstrated excellent work-ethic with self-motivation, ability to work safe with no supervision on customer job<\/p>\n<p>sites, while maintaining company and customer expectations of thoroughness and customer service<\/p>\n<p>\u2022 Ability to read and follow intermediate measurements, schematics, and technical documentation<\/p>\n<p>\u2022 Basic computer skills required using Microsoft Office Suite programs and file sharing<\/p>","%category%":"Operations","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/73a1875aedf8-field-service-technician","%breezy_id%":"73a1875aedf8","%breezy_friendly_id%":"73a1875aedf8-field-service-technician","%breezy_created_date%":"2025-06-18T15:49:08.801Z","%breezy_updated_date%":"2025-07-15T20:19:56.636Z","%_wpgmp_location_city%":"Kansas City","%_wpgmp_location_state%":"MO","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Kansas City, MO, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"39.0997265","%_wpgmp_metabox_longitude%":"-94.5785667","%rank_math_internal_links_processed%":"1"}},"id":2549,"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-06-18T15:05:13.904Z","%_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":"Heavy Equipment Fuel Lube Technician","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Heavy Equipment Fuel Lube Technician\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Heavy Equipment Fuel &amp; Lube Technician Job Description Do you love mining? Do you think differently? Are you ready to&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/heavy-equipment-fuel-lube-technician-2\/\" name=\"Heavy Equipment Fuel Lube Technician\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Heavy Equipment Fuel &amp; Lube Technician Job Description Do you love mining? Do you think differently? Are you ready to&hellip;","address":"Kermit, TX, USA","location":{"lat":"31.8576265","city":"Kermit","state":"TX","country":"United States","lng":"-103.0926652","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/heavy-equipment-fuel-lube-technician-2\/","zoom":19,"extra_fields":{"post_excerpt":"Heavy Equipment Fuel &amp; Lube Technician Job Description Do you love mining? Do you think differently? Are you ready to&hellip;","post_content":"<p style=\"color:#000000\"><strong><u>Heavy Equipment Fuel &amp; Lube Technician Job Description<\/u><\/strong><\/p>\n<p style=\"color:#000000\"><span style=\"color:#333333\">Do you love mining? Do you think differently? Are you ready to define the future of this industry?<\/span><\/p>\n<p style=\"color:#000000\"><span style=\"color:#333333\">We\u2019ve been waiting for you! Turner Mining Group is committed to changing the way mining companies do business. We develop our people. We partner with our clients. We believe in win, win, win.<\/span><\/p>\n<p>We are looking for a dynamic and talented professional to fill a&nbsp;<strong>Fuel &amp; Lube Technician<\/strong>&nbsp;role at our fast-growing, forward thinking mining services company.<\/p>\n<p style=\"color:#000000\"><span style=\"color:#333333\">This person will function as a&nbsp;<\/span><strong>Fuel &amp; Lube Technician<\/strong><span style=\"color:#333333\">, willingness to do, learn, perform and improve any maintenance task. Tasks will be defined and evolve in all areas of mining operations to ensure preventative maintenance is practiced, repairs, equipment runs in the area of responsibility. This is an opportunity to work as part of the operations team in a safe, productive, and fun environment.<\/span><\/p>\n<p style=\"color:#000000\"><span style=\"color:#333333\"><\/span><strong><span style=\"color:#333333\">Essential Skills &amp; Knowledge<\/span><\/strong><\/p>\n<p style=\"color:#000000\"><span style=\"color:#333333\">\u2022 Follow a consistent and regular schedule to perform various types of maintenance on heavy equipment and various pieces of machinery&nbsp;<\/span><\/p>\n<p style=\"color:#000000\"><span style=\"color:#333333\">\u2022 Perform minor repairs on equipment using tools, machine tools and measuring instruments&nbsp;<\/span><span style=\"color:#333333\"><\/span><\/p>\n<p style=\"color:#000000\"><span style=\"color:#333333\">\u2022 Conduct oil changes, lubrication of equipment, tire replacements, hose repairs, battery replacements and assorted services&nbsp;<\/span><span style=\"color:#333333\"><\/span><\/p>\n<p style=\"color:#000000\"><span style=\"color:#333333\">\u2022 Operate and test equipment&nbsp;<\/span><span style=\"color:#333333\"><\/span><\/p>\n<p style=\"color:#000000\"><span style=\"color:#333333\">\u2022 Produce detailed service reports and repair logs&nbsp;<\/span><\/p>\n<p style=\"color:#000000\"><span style=\"color:#333333\">\u2022 Follow all established procedures and protocols&nbsp;<\/span><\/p>\n<p style=\"color:#000000\"><span style=\"color:#333333\">\u2022 Build positive relationships with internal and external teams<\/span><\/p>\n<p style=\"color:#000000\"><span style=\"color:#333333\">\u2022 Perform additional duties as assigned<\/span><\/p>\n<p style=\"color:#000000\"><strong><span style=\"color:#333333\">Benefits<\/span><\/strong><\/p>\n<p style=\"color:#000000\"><span style=\"color:#333333\">Turner Mining Group offers a competitive salary, an excellent work culture, career advancement opportunities. Our team offers a benefits program which includes Medical, Dental, Vision, Life, and a 401k with company match. We believe in a work life balance and established paid time off for major holidays.<\/span><\/p>\n<p style=\"color:#000000\"><span style=\"color:#333333\">At Turner Mining Group, we encourage and celebrate an inclusive environment for all employees and are proud to be an equal opportunity workplace and affirmative action employer.<\/span><\/p>","post_title":"Heavy Equipment Fuel Lube Technician","post_link":"https:\/\/turnerstaffing.com\/position\/heavy-equipment-fuel-lube-technician-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:#000000;\"><strong><u>Heavy Equipment Fuel &amp; Lube Technician Job Description<\/u><\/strong><\/p>\n<p style=\"color:#000000;\"><span style=\"color:#333333;\">Do you love mining? Do you think differently? Are you ready to define the future of this industry?<\/span><\/p>\n<p style=\"color:#000000;\"><span style=\"color:#333333;\">We\u2019ve been waiting for you! Turner Mining Group is committed to changing the way mining companies do business. We develop our people. We partner with our clients. We believe in win, win, win.<\/span><\/p>\n<p>We are looking for a dynamic and talented professional to fill a&nbsp;<strong>Fuel &amp; Lube Technician<\/strong>&nbsp;role at our fast-growing, forward thinking mining services company.<\/p>\n<p style=\"color:#000000;\"><span style=\"color:#333333;\">This person will function as a&nbsp;<\/span><strong>Fuel &amp; Lube Technician<\/strong><span style=\"color:#333333;\">, willingness to do, learn, perform and improve any maintenance task. Tasks will be defined and evolve in all areas of mining operations to ensure preventative maintenance is practiced, repairs, equipment runs in the area of responsibility. This is an opportunity to work as part of the operations team in a safe, productive, and fun environment.<\/span><\/p>\n<p style=\"color:#000000;\"><span style=\"color:#333333;\"><\/span><strong><span style=\"color:#333333;\">Essential Skills &amp; Knowledge<\/span><\/strong><\/p>\n<p style=\"color:#000000;\"><span style=\"color:#333333;\">\u2022 Follow a consistent and regular schedule to perform various types of maintenance on heavy equipment and various pieces of machinery&nbsp;<\/span><\/p>\n<p style=\"color:#000000;\"><span style=\"color:#333333;\">\u2022 Perform minor repairs on equipment using tools, machine tools and measuring instruments&nbsp;<\/span><span style=\"color:#333333;\"><\/span><\/p>\n<p style=\"color:#000000;\"><span style=\"color:#333333;\">\u2022 Conduct oil changes, lubrication of equipment, tire replacements, hose repairs, battery replacements and assorted services&nbsp;<\/span><span style=\"color:#333333;\"><\/span><\/p>\n<p style=\"color:#000000;\"><span style=\"color:#333333;\">\u2022 Operate and test equipment&nbsp;<\/span><span style=\"color:#333333;\"><\/span><\/p>\n<p style=\"color:#000000;\"><span style=\"color:#333333;\">\u2022 Produce detailed service reports and repair logs&nbsp;<\/span><\/p>\n<p style=\"color:#000000;\"><span style=\"color:#333333;\">\u2022 Follow all established procedures and protocols&nbsp;<\/span><\/p>\n<p style=\"color:#000000;\"><span style=\"color:#333333;\">\u2022 Build positive relationships with internal and external teams<\/span><\/p>\n<p style=\"color:#000000;\"><span style=\"color:#333333;\">\u2022 Perform additional duties as assigned<\/span><\/p>\n<p style=\"color:#000000;\"><strong><span style=\"color:#333333;\">Benefits<\/span><\/strong><\/p>\n<p style=\"color:#000000;\"><span style=\"color:#333333;\">Turner Mining Group offers a competitive salary, an excellent work culture, career advancement opportunities. Our team offers a benefits program which includes Medical, Dental, Vision, Life, and a 401k with company match. We believe in a work life balance and established paid time off for major holidays.<\/span><\/p>\n<p style=\"color:#000000;\"><span style=\"color:#333333;\">At Turner Mining Group, we encourage and celebrate an inclusive environment for all employees and are proud to be an equal opportunity workplace and affirmative action employer.<\/span><\/p>","%category%":"Operations","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/aadd4302e14b-heavy-equipment-fuel-lube-technician","%breezy_id%":"aadd4302e14b","%breezy_friendly_id%":"aadd4302e14b-heavy-equipment-fuel-lube-technician","%breezy_created_date%":"2022-09-23T19:46:37.705Z","%breezy_updated_date%":"2025-06-19T18:52:25.557Z","%_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":2546,"infowindow_disable":false},{"source":"post","title":"Paving Department Manager","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Paving Department Manager\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Description The Paving Department Manager is responsible for overseeing all aspects of the milling &amp; paving operations within the company.&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/paving-department-manager\/\" name=\"Paving Department Manager\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Description The Paving Department Manager is responsible for overseeing all aspects of the milling &amp; paving operations within the company.&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\/paving-department-manager\/","zoom":19,"extra_fields":{"post_excerpt":"Description The Paving Department Manager is responsible for overseeing all aspects of the milling &amp; paving operations within the company.&hellip;","post_content":"<p><strong>Description<\/strong><\/p>\n<p>   <\/p>\n<p>The Paving Department Manager is responsible for overseeing all aspects of the milling &amp; paving operations within the company. This role involves managing multiple paving crews\u2019 personnel, equipment, budgets, and schedules to ensure that projects are completed safely, efficiently, and to high quality standards. The Paving Department Manager acts as a key liaison between clients, subcontractors, and our client's teams to maintain excellent customer service and operational excellence.<\/p>\n<p><strong><u>ESSENTIAL DUTIES AND RESPONSIBILITIES:<\/u><\/strong> <\/p>\n<p>Include the following. Other duties may be assigned.<\/p>\n<p><strong>Safety and Quality Control:<\/strong><\/p>\n<ul>\n <li>Ensure      that the safety and welfare of employees are prioritized in every decision      and action.<\/li>\n <li>Encouraging      a no-compromise attitude toward unsafe practices, with appropriate      consequences for violations.<\/li>\n <li>Ensure      that all paving work meets or exceeds quality standards and client      expectations.<\/li>\n <li>Knowledgeable      of PA DOT Publication 408<\/li>\n <li>Understand      and enforce all company safety policies, practices, and procedures.<\/li>\n <li>Conduct      regular safety meetings and site inspections.<\/li>\n <li>Work      with our client's Trainer to develop and implement training for paving best      practices.<\/li>\n<\/ul>\n<p><strong>Team Leadership:<\/strong><\/p>\n<ul>\n <li>Recruit,      train, and manage paving crews to build a high-performing team.<\/li>\n <li>Provide      ongoing coaching and performance evaluations for team members.<\/li>\n <li>Foster      a positive and collaborative work environment that aligns with company      core values.<\/li>\n<\/ul>\n<p><strong>Operational Management:<\/strong><\/p>\n<ul>\n <li>Plan,      schedule, and oversee all milling &amp; paving operations, ensuring timely      and efficient project completion.<\/li>\n <li>Supervise      paving crews and subcontractors, ensuring proper execution of work.<\/li>\n <li>Collaborate      with other internal departments to coordinate site\/utility activities.<\/li>\n <li>Monitor      project progress and adjust schedules as needed to maintain project      timelines while maximizing efficient workflow.<\/li>\n<\/ul>\n<p><strong>Financial and Resource Management:<\/strong><\/p>\n<ul>\n <li>Develop      and manage the paving department budget, ensuring cost-effective use of      resources.<\/li>\n <li>Manage      &amp; track project costs, ensuring profitability and adherence to      budgets.<\/li>\n <li>Optimize      the use of equipment, materials, and personnel.<\/li>\n <li>Works      closely with estimating to prepare and review bids for paving projects for      internal and external clients.<\/li>\n<\/ul>\n<p><strong>Client Relations &amp; Business Development<\/strong><\/p>\n<ul>\n <li>Serve      as the primary point of contact for clients on paving-related matters.<\/li>\n <li>Collaborate      with project managers, estimators, and Site Superintendents to deliver      seamless project execution.<\/li>\n <li>Identify      and pursue new client opportunities for paving, grow outside sales revenue      for the paving department. <\/li>\n<\/ul>\n<p><strong><u>EDUCATION and\/or EXPERIENCE:<\/u><\/strong> <\/p>\n<ul>\n <li>Bachelor\u2019s      degree in construction management, civil engineering, or a related field      (preferred but not required).<\/li>\n <li>Minimum      of 7 years of experience in paving operations, with at least 3 years in a      supervisory or management role.<\/li>\n<\/ul>","post_title":"Paving Department Manager","post_link":"https:\/\/turnerstaffing.com\/position\/paving-department-manager\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Senior","%location_country%":"United States","%location_city%":"Bowmansville","%location_state_id%":"PA","%location_state_name%":"Pennsylvania","%location_city_state%":"Bowmansville, PA","%education%":"Bachelor's Degree","%department%":"","%description%":"<p><strong>Description<\/strong><\/p>\n<p>   <\/p>\n<p>The Paving Department Manager is responsible for overseeing all aspects of the milling &amp; paving operations within the company. This role involves managing multiple paving crews\u2019 personnel, equipment, budgets, and schedules to ensure that projects are completed safely, efficiently, and to high quality standards. The Paving Department Manager acts as a key liaison between clients, subcontractors, and our client's teams to maintain excellent customer service and operational excellence.<\/p>\n<p><strong><u>ESSENTIAL DUTIES AND RESPONSIBILITIES:<\/u><\/strong> <\/p>\n<p>Include the following. Other duties may be assigned.<\/p>\n<p><strong>Safety and Quality Control:<\/strong><\/p>\n<ul>\n <li>Ensure      that the safety and welfare of employees are prioritized in every decision      and action.<\/li>\n <li>Encouraging      a no-compromise attitude toward unsafe practices, with appropriate      consequences for violations.<\/li>\n <li>Ensure      that all paving work meets or exceeds quality standards and client      expectations.<\/li>\n <li>Knowledgeable      of PA DOT Publication 408<\/li>\n <li>Understand      and enforce all company safety policies, practices, and procedures.<\/li>\n <li>Conduct      regular safety meetings and site inspections.<\/li>\n <li>Work      with our client's Trainer to develop and implement training for paving best      practices.<\/li>\n<\/ul>\n<p><strong>Team Leadership:<\/strong><\/p>\n<ul>\n <li>Recruit,      train, and manage paving crews to build a high-performing team.<\/li>\n <li>Provide      ongoing coaching and performance evaluations for team members.<\/li>\n <li>Foster      a positive and collaborative work environment that aligns with company      core values.<\/li>\n<\/ul>\n<p><strong>Operational Management:<\/strong><\/p>\n<ul>\n <li>Plan,      schedule, and oversee all milling &amp; paving operations, ensuring timely      and efficient project completion.<\/li>\n <li>Supervise      paving crews and subcontractors, ensuring proper execution of work.<\/li>\n <li>Collaborate      with other internal departments to coordinate site\/utility activities.<\/li>\n <li>Monitor      project progress and adjust schedules as needed to maintain project      timelines while maximizing efficient workflow.<\/li>\n<\/ul>\n<p><strong>Financial and Resource Management:<\/strong><\/p>\n<ul>\n <li>Develop      and manage the paving department budget, ensuring cost-effective use of      resources.<\/li>\n <li>Manage      &amp; track project costs, ensuring profitability and adherence to      budgets.<\/li>\n <li>Optimize      the use of equipment, materials, and personnel.<\/li>\n <li>Works      closely with estimating to prepare and review bids for paving projects for      internal and external clients.<\/li>\n<\/ul>\n<p><strong>Client Relations &amp; Business Development<\/strong><\/p>\n<ul>\n <li>Serve      as the primary point of contact for clients on paving-related matters.<\/li>\n <li>Collaborate      with project managers, estimators, and Site Superintendents to deliver      seamless project execution.<\/li>\n <li>Identify      and pursue new client opportunities for paving, grow outside sales revenue      for the paving department. <\/li>\n<\/ul>\n<p><strong><u>EDUCATION and\/or EXPERIENCE:<\/u><\/strong> <\/p>\n<ul>\n <li>Bachelor\u2019s      degree in construction management, civil engineering, or a related field      (preferred but not required).<\/li>\n <li>Minimum      of 7 years of experience in paving operations, with at least 3 years in a      supervisory or management role.<\/li>\n<\/ul>","%category%":"Management","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/4a2311f35124-paving-department-manager","%breezy_id%":"4a2311f35124","%breezy_friendly_id%":"4a2311f35124-paving-department-manager","%breezy_created_date%":"2025-06-17T15:40:03.778Z","%breezy_updated_date%":"2025-06-19T21:09:47.783Z","%_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":2544,"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-9\/\" 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":"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\/haul-truck-driver-9\/","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.<\/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><p><\/p>","post_title":"Haul Truck Driver","post_link":"https:\/\/turnerstaffing.com\/position\/haul-truck-driver-9\/","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><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.<\/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><p><\/p>","%category%":"Operations","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/291c52bb7097-haul-truck-driver","%breezy_id%":"291c52bb7097","%breezy_friendly_id%":"291c52bb7097-haul-truck-driver","%breezy_created_date%":"2025-06-16T14:39:58.109Z","%breezy_updated_date%":"2025-06-16T14:45:11.892Z","%_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":2542,"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-06-16T14:51:35.813Z","%_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 the construction 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 construction world? Do you think differently? Are you ready&hellip;","address":"Clarksville, TN, USA","location":{"lat":"36.5297706","city":"Clarksville","state":"TN","country":"United States","lng":"-87.3611694","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 construction 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 construction 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 Clarksville, TN 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%":"Mid Level","%location_country%":"United States","%location_city%":"Clarksville","%location_state_id%":"TN","%location_state_name%":"Tennessee","%location_city_state%":"Clarksville, TN","%education%":"Unspecified","%department%":"","%description%":"<p><strong><u>Turner Staffing Group \u2013 Haul Truck Driver<\/u><\/strong><\/p>\n<p>Do you love the construction 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 Clarksville, TN 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\/4aaee05961eb-haul-truck-driver","%breezy_id%":"4aaee05961eb","%breezy_friendly_id%":"4aaee05961eb-haul-truck-driver","%breezy_created_date%":"2025-04-04T13:48:05.250Z","%breezy_updated_date%":"2025-07-29T15:51:02.308Z","%_wpgmp_location_city%":"Clarksville","%_wpgmp_location_state%":"TN","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Clarksville, TN, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"36.5297706","%_wpgmp_metabox_longitude%":"-87.3611694","%rank_math_internal_links_processed%":"1"}},"id":2541,"infowindow_disable":false},{"source":"post","title":"Off Road Haul Truck Operator","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Off Road Haul Truck Operator\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Turner Mining Group \u2013 Haul Truck Driver Do you love mining? Do you think differently? Are you ready to define&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/off-road-haul-truck-operator\/\" name=\"Off Road Haul Truck Operator\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Turner Mining Group \u2013 Haul Truck Driver Do you love mining? Do you think differently? Are you ready to define&hellip;","address":"Pacific, MO, USA","location":{"lat":"38.4819976","city":"Pacific","state":"MO","country":"United States","lng":"-90.7415194","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/off-road-haul-truck-operator\/","zoom":19,"extra_fields":{"post_excerpt":"Turner Mining Group \u2013 Haul Truck Driver Do you love mining? Do you think differently? Are you ready to define&hellip;","post_content":"<p><strong><u>Turner Mining Group \u2013 Haul Truck Driver<\/u><\/strong><\/p>\n<p>Do you love mining? Do you think differently? Are you ready to define the future of this industry?<\/p>\n<p>We\u2019ve been waiting for you! <\/p>\n<p>Turner Mining Group is committed to changing the way mining companies do business. We develop our people. We partner with our clients. We believe in win, win, win.<\/p>\n<p>We are looking for a dynamic and talented mining Haul Truck Drivers for our fast-growing, forward thinking mining services company headquartered in Bloomington, Indiana with our Operations team headquartered in Salt Lake City, Utah.<\/p>\n<p>Turner Mining Group is seeking an energetic mining professionals who can leverage their mining knowledge to expand upon our fast-growing business, creating best practices for equipment operations to ensure profitable operations.<\/p>\n<p>If you would like to get involved and make a large contribution in mining or minerals processing, then you may enjoy a position as Haul Truck Driver. This position is great for anyone who would like to begin a career in mining, has experience in a related industry but would like to learn about mining, or has experience as a miner but would like to grow into further positions with Turner Mining Group.<\/p>\n<p><strong>You<\/strong><\/p>\n<p>You want to work for a services company that is rapidly changing the way the largest materials producers do business. You are motivated by solving problems and partnering with our clients and suppliers. You want to work with great people and enjoy being a part of a strong team. You are a knowledgeable Operator who is not afraid to jump into every detail. You want to be in a place where continuous learning and growth is the norm. You are adaptable and able to juggle multiple initiatives concurrently.<\/p>\n<p><strong>Responsibilities:<\/strong><\/p>\n<ul><li>Operate and drive heavy haul trucks to transport tons of materials over short distances in a surface environment.<\/li><li>Perform inspections of vehicle systems, equipment and accessories such as tires, lights, turn signals and brakes<\/li><li>Ensure cargo is properly loaded according to safety requirements<\/li><li>Follow all safety policies, procedures and legislation<\/li><li>Maintain paper or electronic logbook<\/li><li>Communicate with Dispatcher and other Haul Truck Drivers using communication devices such as a two-ways radio or onboard computers<\/li><li>May drive special purpose vehicles, including end dump trucks, center dump truck units and water trucks<\/li><\/ul>\n<p><strong>Requirements:<\/strong><\/p>\n<ul><li>Safety oriented, awareness of everyone and everything that is around you<\/li><li>Strong work ethic<\/li><li>Willingness to learn<\/li><li>Ability to be flexible and to adapt<\/li><li>Experience with heavy equipment<\/li><li>Preferred to have MSHA training<\/li><\/ul>\n<p><strong>Benefits:<\/strong><\/p>\n<p>Turner Mining Group offers a competitive salary, an excellent work culture, career advancement opportunities. Our team offers a benefits program which includes Medical, Dental, Vision, Life, and a 401k with company match.<\/p>\n<p>At Turner Mining Group, we encourage and celebrate an inclusive environment for all employees and are proud to be an equal opportunity workplace and affirmative action employer.<\/p>","post_title":"Off Road Haul Truck Operator","post_link":"https:\/\/turnerstaffing.com\/position\/off-road-haul-truck-operator\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Associate","%location_country%":"United States","%location_city%":"Pacific","%location_state_id%":"MO","%location_state_name%":"Missouri","%location_city_state%":"Pacific, MO","%education%":"Unspecified","%department%":"Operations","%description%":"<p><strong><u>Turner Mining Group \u2013 Haul Truck Driver<\/u><\/strong><\/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\/b65014c3109c-off-road-haul-truck-operator","%breezy_id%":"b65014c3109c","%breezy_friendly_id%":"b65014c3109c-off-road-haul-truck-operator","%breezy_created_date%":"2025-06-12T20:49:59.963Z","%breezy_updated_date%":"2025-06-12T20:50:41.948Z","%_wpgmp_location_city%":"Pacific","%_wpgmp_location_state%":"MO","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Pacific, MO, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"38.4819976","%_wpgmp_metabox_longitude%":"-90.7415194","%rank_math_internal_links_processed%":"1"}},"id":2540,"infowindow_disable":false},{"source":"post","title":"Water Truck Operator","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Water Truck Operator\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Turner Mining Group \u2013 Heavy Equipment Operator &#8211; Water Truck We are looking for a dynamic and talented mining Heavy&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/water-truck-operator\/\" name=\"Water Truck Operator\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Turner Mining Group \u2013 Heavy Equipment Operator &#8211; Water Truck We are looking for a dynamic and talented mining Heavy&hellip;","address":"Ludlow, VT, USA","location":{"lat":"43.3960723","city":"Ludlow","state":"VT","country":"United States","lng":"-72.7010471","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/water-truck-operator\/","zoom":19,"extra_fields":{"post_excerpt":"Turner Mining Group \u2013 Heavy Equipment Operator &#8211; Water Truck We are looking for a dynamic and talented mining Heavy&hellip;","post_content":"<p><strong><u>Turner Mining Group \u2013 Heavy Equipment Operator - Water Truck<\/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":"Water Truck Operator","post_link":"https:\/\/turnerstaffing.com\/position\/water-truck-operator\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Entry Level","%location_country%":"United States","%location_city%":"Ludlow","%location_state_id%":"VT","%location_state_name%":"Vermont","%location_city_state%":"Ludlow, VT","%education%":"Unspecified","%department%":"Operations","%description%":"<p><strong><u>Turner Mining Group \u2013 Heavy Equipment Operator - Water Truck<\/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%":"Other","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/105d490652c5-water-truck-operator","%breezy_id%":"105d490652c5","%breezy_friendly_id%":"105d490652c5-water-truck-operator","%breezy_created_date%":"2025-06-12T15:15:09.202Z","%breezy_updated_date%":"2025-06-12T15:15:53.130Z","%_wpgmp_location_city%":"Ludlow","%_wpgmp_location_state%":"VT","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Ludlow, VT, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"43.3960723","%_wpgmp_metabox_longitude%":"-72.7010471","%rank_math_internal_links_processed%":"1"}},"id":2538,"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%":"2025-06-19T18:14:03.952Z","%_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":"Maintenance Technician- Mining","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Maintenance Technician- Mining\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Turner Staffing Group &#8211; Maintenance Technician 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\/maintenance-technician-mining\/\" name=\"Maintenance Technician- Mining\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Turner Staffing Group &#8211; Maintenance Technician 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\/maintenance-technician-mining\/","zoom":19,"extra_fields":{"post_excerpt":"Turner Staffing Group &#8211; Maintenance Technician Do you love mining? Do you think differently? Are you ready to define the&hellip;","post_content":"<p><strong><u>Turner Staffing Group - Maintenance 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 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><\/p>\n<p>We are looking for a dynamic and talented professional to fill a Maintenance Technician role for our fast-growing, forward thinking mining client.<\/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 Maintenance Technician, 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>You<\/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 Maintenance Technician 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\"><span style=\"color:#333333\"> <\/span><\/p>\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 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\"><span style=\"color:#333333\"> <\/span><br><\/p>","post_title":"Maintenance Technician- Mining","post_link":"https:\/\/turnerstaffing.com\/position\/maintenance-technician-mining\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Mid Level","%location_country%":"United States","%location_city%":"Crane","%location_state_id%":"TX","%location_state_name%":"Texas","%location_city_state%":"Crane, TX","%education%":"Unspecified","%department%":"","%description%":"<p><strong><u>Turner Staffing Group - Maintenance 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 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><\/p>\n<p>We are looking for a dynamic and talented professional to fill a Maintenance Technician role for our fast-growing, forward thinking mining client.<\/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 Maintenance Technician, 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>You<\/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 Maintenance Technician 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;\"><span style=\"color:#333333;\"> <\/span><\/p>\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 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;\"><span style=\"color:#333333;\"> <\/span><br><\/p>","%category%":"Operations","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/3eb0e471a4a6-maintenance-technician-mining","%breezy_id%":"3eb0e471a4a6","%breezy_friendly_id%":"3eb0e471a4a6-maintenance-technician-mining","%breezy_created_date%":"2025-06-11T16:26:56.444Z","%breezy_updated_date%":"2025-06-11T16:27:33.373Z","%_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":2534,"infowindow_disable":false},{"source":"post","title":"Maintenance Technician- Mining","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Maintenance Technician- Mining\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Turner Staffing Group &#8211; Maintenance Technician 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\/maintenance-technician-mining-2\/\" name=\"Maintenance Technician- Mining\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Turner Staffing Group &#8211; Maintenance Technician Do you love mining? Do you think differently? Are you ready to define the&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\/maintenance-technician-mining-2\/","zoom":19,"extra_fields":{"post_excerpt":"Turner Staffing Group &#8211; Maintenance Technician Do you love mining? Do you think differently? Are you ready to define the&hellip;","post_content":"<p><strong><u>Turner Staffing Group - Maintenance 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 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><\/p>\n<p>We are looking for a dynamic and talented professional to fill a Maintenance Technician&nbsp;role for our fast-growing, forward thinking mining client.<\/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 Maintenance Technician, 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>You<\/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 Maintenance Technician&nbsp;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\"><span style=\"color:#333333\"><\/span><\/p>\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 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>","post_title":"Maintenance Technician- Mining","post_link":"https:\/\/turnerstaffing.com\/position\/maintenance-technician-mining-2\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Mid Level","%location_country%":"United States","%location_city%":"Lamesa","%location_state_id%":"TX","%location_state_name%":"Texas","%location_city_state%":"Lamesa, TX","%education%":"Unspecified","%department%":"","%description%":"<p><strong><u>Turner Staffing Group - Maintenance 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 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><\/p>\n<p>We are looking for a dynamic and talented professional to fill a Maintenance Technician&nbsp;role for our fast-growing, forward thinking mining client.<\/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 Maintenance Technician, 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>You<\/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 Maintenance Technician&nbsp;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;\"><span style=\"color:#333333;\"><\/span><\/p>\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 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>","%category%":"Operations","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/cbee7ed7ad91-maintenance-technician-mining","%breezy_id%":"cbee7ed7ad91","%breezy_friendly_id%":"cbee7ed7ad91-maintenance-technician-mining","%breezy_created_date%":"2025-06-11T16:29:06.689Z","%breezy_updated_date%":"2025-06-11T16:29:38.042Z","%_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":2535,"infowindow_disable":false},{"source":"post","title":"Scraper Operator &#8211; Mining","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Scraper Operator &#8211; Mining\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Turner Mining Group \u2013 Heavy Equipment Operator Do you love mining? Do you think differently? Are you ready to define&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/scraper-operator-mining\/\" name=\"Scraper Operator &#8211; Mining\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Turner Mining Group \u2013 Heavy Equipment Operator Do you love mining? Do you think differently? Are you ready to define&hellip;","address":"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\/scraper-operator-mining\/","zoom":19,"extra_fields":{"post_excerpt":"Turner Mining Group \u2013 Heavy Equipment Operator Do you love mining? Do you think differently? Are you ready to define&hellip;","post_content":"<p><strong><u>Turner Mining Group \u2013 Heavy Equipment Operator<\/u><\/strong><\/p>\n<p>Do you love mining? Do you think differently? Are you ready to define the future of this industry?<\/p>\n<p>We\u2019ve been waiting for you! Turner Mining Group is committed to changing the way mining companies do business. We develop our people. We partner with our clients. We believe in win, win, win.<\/p>\n<p>We are looking for a dynamic and talented mining Heavy Equipment Operators for our fast-growing, forward thinking mining services company headquartered in Bloomington, Indiana with our Operations team headquartered in Salt Lake City, Utah.<\/p>\n<p>Turner Mining Group is seeking an energetic mining professionals who can leverage their mining knowledge to expand upon our fast-growing business, creating best practices for equipment operations to ensure profitable operations.<\/p>\n<p><strong>You<\/strong><\/p>\n<p>You want to work for a services company that is rapidly changing the way the largest materials producers do business. You are motivated by solving problems and partnering with our clients and suppliers. You want to work with great people and enjoy being a part of a strong team. You are a knowledgeable Operator who is not afraid to jump into every detail. You want to be in a place where continuous learning and growth is the norm. You are adaptable and able to juggle multiple initiatives concurrently.<\/p>\n<p><strong>Responsibilities:<\/strong><\/p>\n<ul><li>Operating heavy equipment including loaders, scrapers, blade, excavators, dozers, haul trucks, and other pieces of heavy equipment in a production environment<\/li><li>Performing all pre-shift inspections, some basic maintenance and upkeep<\/li><li>Working with teammates on crew to maximize production while always maintaining our safety rules and regulations.<\/li><\/ul>\n<p><strong>Requirements:<\/strong><\/p>\n<ul><li>Safety oriented, awareness of everyone and everything that is around you<\/li><li>Strong work ethic<\/li><li>Willingness to learn<\/li><li>Ability to be flexible and to adapt<\/li><li>Experience with heavy equipment<\/li><li>Preferred to have MSHA training<\/li><\/ul>\n<p><strong>Benefits:<\/strong><\/p>\n<p>Turner Mining Group offers a competitive salary, an excellent work culture, career advancement opportunities. Our team offers a benefits program which includes Medical, Dental, Vision, Life, and a 401k with company match.<\/p>\n<p>At Turner Mining Group, we encourage and celebrate an inclusive environment for all employees and are proud to be an equal opportunity workplace and affirmative action employer.<\/p>","post_title":"Scraper Operator &#8211; Mining","post_link":"https:\/\/turnerstaffing.com\/position\/scraper-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%":"<p><strong><u>Turner Mining Group \u2013 Heavy Equipment Operator<\/u><\/strong><\/p>\n<p>Do you love mining? Do you think differently? Are you ready to define the future of this industry?<\/p>\n<p>We\u2019ve been waiting for you! Turner Mining Group is committed to changing the way mining companies do business. We develop our people. We partner with our clients. We believe in win, win, win.<\/p>\n<p>We are looking for a dynamic and talented mining Heavy Equipment Operators for our fast-growing, forward thinking mining services company headquartered in Bloomington, Indiana with our Operations team headquartered in Salt Lake City, Utah.<\/p>\n<p>Turner Mining Group is seeking an energetic mining professionals who can leverage their mining knowledge to expand upon our fast-growing business, creating best practices for equipment operations to ensure profitable operations.<\/p>\n<p><strong>You<\/strong><\/p>\n<p>You want to work for a services company that is rapidly changing the way the largest materials producers do business. You are motivated by solving problems and partnering with our clients and suppliers. You want to work with great people and enjoy being a part of a strong team. You are a knowledgeable Operator who is not afraid to jump into every detail. You want to be in a place where continuous learning and growth is the norm. You are adaptable and able to juggle multiple initiatives concurrently.<\/p>\n<p><strong>Responsibilities:<\/strong><\/p>\n<ul><li>Operating heavy equipment including loaders, scrapers, blade, excavators, dozers, haul trucks, and other pieces of heavy equipment in a production environment<\/li><li>Performing all pre-shift inspections, some basic maintenance and upkeep<\/li><li>Working with teammates on crew to maximize production while always maintaining our safety rules and regulations.<\/li><\/ul>\n<p><strong>Requirements:<\/strong><\/p>\n<ul><li>Safety oriented, awareness of everyone and everything that is around you<\/li><li>Strong work ethic<\/li><li>Willingness to learn<\/li><li>Ability to be flexible and to adapt<\/li><li>Experience with heavy equipment<\/li><li>Preferred to have MSHA training<\/li><\/ul>\n<p><strong>Benefits:<\/strong><\/p>\n<p>Turner Mining Group offers a competitive salary, an excellent work culture, career advancement opportunities. Our team offers a benefits program which includes Medical, Dental, Vision, Life, and a 401k with company match.<\/p>\n<p>At Turner Mining Group, we encourage and celebrate an inclusive environment for all employees and are proud to be an equal opportunity workplace and affirmative action employer.<\/p>","%category%":"Operations","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/2a0b57b02abf-scraper-operator-mining","%breezy_id%":"2a0b57b02abf","%breezy_friendly_id%":"2a0b57b02abf-scraper-operator-mining","%breezy_created_date%":"2025-01-22T16:51:25.603Z","%breezy_updated_date%":"2025-07-16T14:32:51.109Z","%_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":2528,"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-06-10T16:36:56.438Z","%_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":"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    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\/loader-operator-2\/\" name=\"Loader 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":"Columbia, SC, USA","location":{"lat":"34.0008322","city":"Columbia","state":"SC","country":"United States","lng":"-81.035147","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/loader-operator-2\/","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 Heavy Equipment Operators for our fast-growing, forward thinking mining client in Columbia,&nbsp;SC.<\/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 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, skid steers, 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":"Loader Operator","post_link":"https:\/\/turnerstaffing.com\/position\/loader-operator-2\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Associate","%location_country%":"United States","%location_city%":"Columbia","%location_state_id%":"SC","%location_state_name%":"South Carolina","%location_city_state%":"Columbia, SC","%education%":"Unspecified","%department%":"","%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 Heavy Equipment Operators for our fast-growing, forward thinking mining client in Columbia,&nbsp;SC.<\/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 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, skid steers, 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\/66956e2d705c-loader-operator","%breezy_id%":"66956e2d705c","%breezy_friendly_id%":"66956e2d705c-loader-operator","%breezy_created_date%":"2025-06-10T14:46:56.486Z","%breezy_updated_date%":"2025-07-21T17:22:20.931Z","%_wpgmp_location_city%":"Columbia","%_wpgmp_location_state%":"SC","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Columbia, SC, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"34.0008322","%_wpgmp_metabox_longitude%":"-81.035147","%rank_math_internal_links_processed%":"1"}},"id":2525,"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-06-10T16:36:20.455Z","%_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":"Traveling Superintendent &#8211; Mining","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Traveling 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\/traveling-superintendent-mining-2\/\" name=\"Traveling 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":"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\/traveling-superintendent-mining-2\/","zoom":19,"extra_fields":{"post_excerpt":"Turner Mining Group &#8211; Project Superintendent We are looking for a dynamic and talented mining industry leader to fill a&hellip;","post_content":"<p><strong><u>Turner Mining Group - Project Superintendent <\/u><\/strong><br><\/p>\n\n<p>We are looking for a dynamic and talented mining industry leader to fill a Traveling Project Superintendent role at our fast-growing, forward thinking mining services company.&nbsp;<\/p>\n<p>Turner Mining Group is seeking an energetic mining professional who can leverage their mining industry experience to expand upon our fast-growing business, creating best practices for operations management and scalable business processes to ensure profitable projects. <\/p>\n<p>This person will function as a Project Superintendent, overseeing mining operations, work directly with the Senior Vice President of Mining, develop and mentor on-site management, and coordinating with home-office team. Leadership and an ability to problem solve while ensuring mining operations remain on budget and ahead of schedule. This is an opportunity to work as part of the executive leadership team in a fast-paced and flexible environment.<\/p>\n<p><strong>You<\/strong><\/p>\n<p>You want to work for a services company that is rapidly changing the way the largest mining producers do business. You are motivated by solving problems and partnering with our clients and suppliers. You want to work with great people and enjoy being a part of a strong team. You are a seasoned mining leader who is not afraid to jump into every detail. You want to be in a place where continuous learning and growth is the norm. You are adaptable and able to juggle multiple initiatives concurrently.<\/p>\n<p><strong>Position Overview<\/strong><\/p>\n<p>The Project Superintendent primary responsibility is to oversee mining operations within Turner Mining Group. This will include managing the operational and financial performance of projects, implementing processes to ensure effective personnel growth, equipment readiness, client interactions and problem solving and implementing systems and tools to increase efficiency and ensure profitability. Position reports directly to the Director of Operations.<\/p>\n<p><strong>Key Responsibilities<\/strong><\/p>\n<ul><li>Conduct field personnel development by training and monitoring: Equipment operators, maintenance technicians, grade staking, GPS utilization, foremen\u2019s, etc.<\/li><li>Ownership for project budget, profitability, and cost control<\/li><li>Identify, assist with develop, and understand the key financial and operational metrics for success<\/li><li>Oversee operations for safety and compliance<\/li><li>Developing and leading fields teams to increase performance<\/li><li>Implement business division reporting and metrics reviews<\/li><li>Coordinate site needs, crews for scheduling, planning, and resources<\/li><li>Monitor forward-looking personnel requirements and vendor developments<\/li><li>Negotiate and manage client and vendor relationships<\/li><li>Approve appropriate invoices and proposal submissions<\/li><li>Assist Biz Dev &amp; Estimation Team with Pre-Bid site visits, analysis, and work plans for project proposals<\/li><\/ul>\n<p><strong>Essential Skills &amp; Knowledge<\/strong><\/p>\n<ul><li>Detailed understanding of civil and mining operations<\/li><li>General understanding of business leadership<\/li><li>Ability to oversee operational and organizational performance for mining projects<\/li><li>Solid understanding of financial and operational reporting<\/li><li>Ability to quantify and explain variances to owners and executives succinctly and clearly<\/li><li>Proficiency in civil and mining best practices to perform project management<\/li><li>Intelligent with demonstrated results from creativity<\/li><li>Willingness to learn what is takes to run growing and successful teams<\/li><li>Strong organizational, interpersonal, and written communication skill<\/li><li>Gifted person who can prioritize and balance competing initiatives and activities<\/li><li>Knack for continuous improvement of processes, solution-based issue resolution and outcomes<\/li><li>Organized, problem solver and solution developer, who can work with workers, engineers and owner teams<\/li><li>Believe in the power of culture with strong leadership qualities<\/li><\/ul>\n<p><strong>Benefits<\/strong><\/p>\n<p>Turner Mining Group offers a competitive salary, an excellent work culture, career advancement opportunities. Our team offers a benefits program which includes Medical, Dental, Vision, Life, and a 401k with company match. We believe in a work life balance and established a Paid Time Off policy as well as paid time off for major holidays.<\/p>\n<p>At Turner Mining Group, we encourage and celebrate an inclusive environment for all employees and are proud to be an equal opportunity workplace and affirmative action employer.<\/p>","post_title":"Traveling Superintendent &#8211; Mining","post_link":"https:\/\/turnerstaffing.com\/position\/traveling-superintendent-mining-2\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Senior","%location_country%":"United States","%location_city%":"Midland","%location_state_id%":"TX","%location_state_name%":"Texas","%location_city_state%":"Midland, TX","%education%":"Unspecified","%department%":"Operations","%description%":"<p><strong><u>Turner Mining Group - Project Superintendent <\/u><\/strong><br><\/p>\n\n<p>We are looking for a dynamic and talented mining industry leader to fill a Traveling Project Superintendent role at our fast-growing, forward thinking mining services company.&nbsp;<\/p>\n<p>Turner Mining Group is seeking an energetic mining professional who can leverage their mining industry experience to expand upon our fast-growing business, creating best practices for operations management and scalable business processes to ensure profitable projects. <\/p>\n<p>This person will function as a Project Superintendent, overseeing mining operations, work directly with the Senior Vice President of Mining, develop and mentor on-site management, and coordinating with home-office team. Leadership and an ability to problem solve while ensuring mining operations remain on budget and ahead of schedule. This is an opportunity to work as part of the executive leadership team in a fast-paced and flexible environment.<\/p>\n<p><strong>You<\/strong><\/p>\n<p>You want to work for a services company that is rapidly changing the way the largest mining producers do business. You are motivated by solving problems and partnering with our clients and suppliers. You want to work with great people and enjoy being a part of a strong team. You are a seasoned mining leader who is not afraid to jump into every detail. You want to be in a place where continuous learning and growth is the norm. You are adaptable and able to juggle multiple initiatives concurrently.<\/p>\n<p><strong>Position Overview<\/strong><\/p>\n<p>The Project Superintendent primary responsibility is to oversee mining operations within Turner Mining Group. This will include managing the operational and financial performance of projects, implementing processes to ensure effective personnel growth, equipment readiness, client interactions and problem solving and implementing systems and tools to increase efficiency and ensure profitability. Position reports directly to the Director of Operations.<\/p>\n<p><strong>Key Responsibilities<\/strong><\/p>\n<ul><li>Conduct field personnel development by training and monitoring: Equipment operators, maintenance technicians, grade staking, GPS utilization, foremen\u2019s, etc.<\/li><li>Ownership for project budget, profitability, and cost control<\/li><li>Identify, assist with develop, and understand the key financial and operational metrics for success<\/li><li>Oversee operations for safety and compliance<\/li><li>Developing and leading fields teams to increase performance<\/li><li>Implement business division reporting and metrics reviews<\/li><li>Coordinate site needs, crews for scheduling, planning, and resources<\/li><li>Monitor forward-looking personnel requirements and vendor developments<\/li><li>Negotiate and manage client and vendor relationships<\/li><li>Approve appropriate invoices and proposal submissions<\/li><li>Assist Biz Dev &amp; Estimation Team with Pre-Bid site visits, analysis, and work plans for project proposals<\/li><\/ul>\n<p><strong>Essential Skills &amp; Knowledge<\/strong><\/p>\n<ul><li>Detailed understanding of civil and mining operations<\/li><li>General understanding of business leadership<\/li><li>Ability to oversee operational and organizational performance for mining projects<\/li><li>Solid understanding of financial and operational reporting<\/li><li>Ability to quantify and explain variances to owners and executives succinctly and clearly<\/li><li>Proficiency in civil and mining best practices to perform project management<\/li><li>Intelligent with demonstrated results from creativity<\/li><li>Willingness to learn what is takes to run growing and successful teams<\/li><li>Strong organizational, interpersonal, and written communication skill<\/li><li>Gifted person who can prioritize and balance competing initiatives and activities<\/li><li>Knack for continuous improvement of processes, solution-based issue resolution and outcomes<\/li><li>Organized, problem solver and solution developer, who can work with workers, engineers and owner teams<\/li><li>Believe in the power of culture with strong leadership qualities<\/li><\/ul>\n<p><strong>Benefits<\/strong><\/p>\n<p>Turner Mining Group offers a competitive salary, an excellent work culture, career advancement opportunities. Our team offers a benefits program which includes Medical, Dental, Vision, Life, and a 401k with company match. We believe in a work life balance and established a Paid Time Off policy as well as paid time off for major holidays.<\/p>\n<p>At Turner Mining Group, we encourage and celebrate an inclusive environment for all employees and are proud to be an equal opportunity workplace and affirmative action employer.<\/p>","%category%":"Operations","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/4bb28f921a26-traveling-superintendent-mining","%breezy_id%":"4bb28f921a26","%breezy_friendly_id%":"4bb28f921a26-traveling-superintendent-mining","%breezy_created_date%":"2024-12-10T13:58:54.602Z","%breezy_updated_date%":"2025-07-08T19:17:42.425Z","%_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":2524,"infowindow_disable":false},{"source":"post","title":"Heavy Equipment Operator","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Heavy Equipment Operator\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Turner Mining Group \u2013 Heavy Equipment Operator 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\/heavy-equipment-operator-8\/\" name=\"Heavy Equipment Operator\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Turner Mining Group \u2013 Heavy Equipment Operator We are looking for a dynamic and talented mining Heavy Equipment Operators for&hellip;","address":"Ludlow, VT, USA","location":{"lat":"43.3960723","city":"Ludlow","state":"VT","country":"United States","lng":"-72.7010471","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/heavy-equipment-operator-8\/","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":"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%":"Ludlow","%location_state_id%":"VT","%location_state_name%":"Vermont","%location_city_state%":"Ludlow, VT","%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\/cd31b59bc1d4-heavy-equipment-operator","%breezy_id%":"cd31b59bc1d4","%breezy_friendly_id%":"cd31b59bc1d4-heavy-equipment-operator","%breezy_created_date%":"2025-06-09T13:00:28.318Z","%breezy_updated_date%":"2025-06-09T13:01:55.366Z","%_wpgmp_location_city%":"Ludlow","%_wpgmp_location_state%":"VT","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Ludlow, VT, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"43.3960723","%_wpgmp_metabox_longitude%":"-72.7010471","%rank_math_internal_links_processed%":"1"}},"id":2515,"infowindow_disable":false},{"source":"post","title":"Heavy Equipment Operator","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Heavy Equipment Operator\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Turner Mining Group \u2013 Heavy Equipment Operator 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\/heavy-equipment-operator-7\/\" name=\"Heavy Equipment Operator\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Turner Mining Group \u2013 Heavy Equipment Operator We are looking for a dynamic and talented mining Heavy Equipment Operators for&hellip;","address":"Ludlow, VT, USA","location":{"lat":"43.3960723","city":"Ludlow","state":"VT","country":"United States","lng":"-72.7010471","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/heavy-equipment-operator-7\/","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 with our Operations team headquartered in Salt Lake City, Utah.<\/p>\n<p>Turner Mining Group is seeking an energetic mining professionals who can leverage their mining knowledge to expand upon our fast-growing business, creating best practices for equipment operations to ensure profitable operations.<\/p>\n<p><strong>You<\/strong><\/p>\n<p>You want to work for a services company that is rapidly changing the way the largest materials producers do business. You are motivated by solving problems and partnering with our clients and suppliers. You want to work with great people and enjoy being a part of a strong team. You are a knowledgeable Operator who is not afraid to jump into every detail. You want to be in a place where continuous learning and growth is the norm. You are adaptable and able to juggle multiple initiatives concurrently.<\/p>\n<p><strong>Responsibilities:<\/strong><\/p>\n<ul><li>Operating heavy equipment including loaders, scrapers, blade, excavators, dozers, haul trucks, and other pieces of heavy equipment in a production environment<\/li><li>Performing all pre-shift inspections, some basic maintenance and upkeep<\/li><li>Working with teammates on crew to maximize production while always maintaining our safety rules and regulations.<\/li><\/ul>\n<p><strong>Requirements:<\/strong><\/p>\n<ul><li>Safety oriented, awareness of everyone and everything that is around you<\/li><li>Strong work ethic<\/li><li>Willingness to learn<\/li><li>Ability to be flexible and to adapt<\/li><li>Experience with heavy equipment<\/li><li>Preferred to have MSHA training<\/li><\/ul>\n<p><strong>Benefits:<\/strong><\/p>\n<p>Turner Mining Group offers a competitive salary, an excellent work culture, career advancement opportunities. Our team offers a benefits program which includes Medical, Dental, Vision, Life, and a 401k with company match.<\/p>\n<p>At Turner Mining Group, we encourage and celebrate an inclusive environment for all employees and are proud to be an equal opportunity workplace and affirmative action employer.<\/p>","post_title":"Heavy Equipment Operator","post_link":"https:\/\/turnerstaffing.com\/position\/heavy-equipment-operator-7\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Associate","%location_country%":"United States","%location_city%":"Ludlow","%location_state_id%":"VT","%location_state_name%":"Vermont","%location_city_state%":"Ludlow, VT","%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 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\/f221a0f6befb-heavy-equipment-operator","%breezy_id%":"f221a0f6befb","%breezy_friendly_id%":"f221a0f6befb-heavy-equipment-operator","%breezy_created_date%":"2025-06-06T15:18:15.840Z","%breezy_updated_date%":"2025-07-20T15:06:12.783Z","%_wpgmp_location_city%":"Ludlow","%_wpgmp_location_state%":"VT","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Ludlow, VT, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"43.3960723","%_wpgmp_metabox_longitude%":"-72.7010471","%rank_math_internal_links_processed%":"1"}},"id":2511,"infowindow_disable":false},{"source":"post","title":"Dozer Operator &#8211; Mining","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Dozer Operator &#8211; Mining\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Turner Mining Group \u2013 Heavy Equipment Operator Turner Mining Group is seeking an energetic mining professionals who can leverage their&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/dozer-operator-2\/\" name=\"Dozer Operator &#8211; Mining\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Turner Mining Group \u2013 Heavy Equipment Operator Turner Mining Group is seeking an energetic mining professionals who can leverage their&hellip;","address":"Ludlow, VT, USA","location":{"lat":"43.3960723","city":"Ludlow","state":"VT","country":"United States","lng":"-72.7010471","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 Turner Mining Group is seeking an energetic mining professionals who can leverage their&hellip;","post_content":"<p><strong><u>Turner Mining Group \u2013 Heavy Equipment Operator<\/u><\/strong><br><\/p>\n\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 &#8211; Mining","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%":"Ludlow","%location_state_id%":"VT","%location_state_name%":"Vermont","%location_city_state%":"Ludlow, VT","%education%":"Unspecified","%department%":"","%description%":"<p><strong><u>Turner Mining Group \u2013 Heavy Equipment Operator<\/u><\/strong><br><\/p>\n\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\/01c501fa0641-dozer-operator-mining","%breezy_id%":"01c501fa0641","%breezy_friendly_id%":"01c501fa0641-dozer-operator-mining","%breezy_created_date%":"2025-06-04T14:24:17.117Z","%breezy_updated_date%":"2025-07-16T13:46:29.647Z","%_wpgmp_location_city%":"Ludlow","%_wpgmp_location_state%":"VT","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Ludlow, VT, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"43.3960723","%_wpgmp_metabox_longitude%":"-72.7010471","%rank_math_internal_links_processed%":"1"}},"id":2495,"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 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-2\/\" name=\"Mining Foreman\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Turner Mining Group &#8211; Project Foreman Do you love mining? Do you think differently? Are you ready to define the&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\/mining-foreman-2\/","zoom":19,"extra_fields":{"post_excerpt":"Turner Mining Group &#8211; Project Foreman 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<\/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-2\/","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 - Project Foreman<\/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\/45cb082faeda-mining-foreman","%breezy_id%":"45cb082faeda","%breezy_friendly_id%":"45cb082faeda-mining-foreman","%breezy_created_date%":"2025-06-02T16:15:19.503Z","%breezy_updated_date%":"2025-06-02T16:18:34.140Z","%_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":2486,"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 SUMMARY:&nbsp; To perform maintenance inspections, repairs and rebuilds on all plant operating equipment. This role is critical to achieving&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/maintenance-mechanic-2\/\" name=\"Maintenance Mechanic\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"POSITION SUMMARY:&nbsp; To perform maintenance inspections, repairs and rebuilds on all plant operating equipment. This role is critical to achieving&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\/maintenance-mechanic-2\/","zoom":19,"extra_fields":{"post_excerpt":"POSITION SUMMARY:&nbsp; To perform maintenance inspections, repairs and rebuilds on all plant operating equipment. This role is critical to achieving&hellip;","post_content":"<p><strong>POSITION SUMMARY:&nbsp; <\/strong>To perform maintenance inspections, repairs and rebuilds on all plant operating equipment. This role is critical to achieving Plant OEE and Equipment Availability goals by elimination of unplanned stops and extended downtimes.&nbsp; Employees in the position are required to participate in company-sponsored training and certification programs to ensure that their job knowledge and skills meet the 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 as well as SQF initiatives at all times.<ul><li>Must complete and document Workplace Inspections in a timely manner.<\/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 be well versed in the installation and maintenance of all types of bearings.<\/li><li>Must possess a good knowledge of:<ul><li>oil and grease seals and their applications.<\/li><li>lubricants and their uses.<\/li><\/ul><\/li><li>Must be able to perform:<ul><li>shaft alignments using precision alignment tools<\/li><li>chain and sprocket installation and alignments<\/li><li>belt and sheave installation and alignment<\/li><li>wiring of low voltage motors up to 600VAC<\/li><li>minor runs\/ repairs to conduit<\/li><li>replacement of receptacles\/ switches<\/li><li>minor maintenance on loaders, haul trucks, drills, forklifts, maintenance, and plant vehicles<\/li><li>preventive maintenance checks and report findings (both verbally and in writing)<\/li><li>post-job inspections to ensure a high level of housekeeping standards<\/li><\/ul><\/li><li>Must be able to install and align all types of new equipment.<\/li><li>Must be able to disassemble and rebuild all types of crushing, screening, and conveying equipment.<\/li><li>Operate extended forklift, forklift, man lift, or maintenance machinery to perform plant and quarry maintenance.<\/li><li>Must have a high level of rigging skills.<\/li><li>Must have experience and expertise in the installation of pneumatic and hydraulic piping systems including the use of proper fittings and connectors.<\/li><li>Must be able to troubleshoot, service and repair:<ul><li>all plant environmental equipment and demonstrate knowledge of baghouse operation<\/li><li>hydraulic\/pneumatics systems<\/li><li>all types of repairs to air compressors presently in service<\/li><\/ul><\/li><li>Ensure maintenance tools are kept in good condition, repaired or replaced when necessary.<\/li><li>Must possess and maintain a complete set of personal hand tools as per the LNA list.<\/li><li>Must be able to operate plant mobile equipment.<\/li><li>Must be proficient in the use of precision measuring tools (micrometers, dial indicators, etc.).<\/li><li>Must be qualified to weld in all four positions (certification).<\/li><li>Must be proficient in all kinds of acetylene cutting and welding.<\/li><li>Should be able to perform thickness testing.<\/li><li>Understanding of thermography and how it is used at the site.<\/li><li>Should have a complete understanding of non-destructive testing.<\/li><li>Should possess knowledge of the CMMS System and be willing to correctly complete work orders and checklists including signing and dating.<\/li><li>Perform maintenance on crushers, conveyor belts, vibrating feeders, screens, elevators, refractory repairs, kilns, fans, dust collectors, coal mills, screws, pumps, pulverizers, and other plant and quarry equipment.<\/li><li>Must display competency in performing basic electrical work safely.<\/li><li>Must possess and understand the use of DOM\u2019s, Meggers, Amp Meters.<\/li><li>MCC Starter trouble shooting to included testing of control transformers, fuse testing\/replacement, overload heater testing\/replacement.<\/li><li>Semi-annually the employee will be required to display safe practices and procedures under the supervision of a Maintenance Supervisor and Electrician or Electrical Supervisor.<\/li><li>The company will allocate time for the individual to further their advancement.<\/li><li>Perform other duties as assigned.<\/li><\/ul><\/li><\/ul>\n<p><\/p>\n<p><strong>Safe Quality Food (SQF)<\/strong><\/p>\n<ul><li>Ensure a SQF workplace and in 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>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 able to work any shift, overtime, be on-call, or work seven days a week including holidays and be flexible to schedule changes.<\/li><li>Industrial background with good troubleshooting skills.<\/li><li>Must be able perform basic mathematical computations.<\/li><li>Ability to detect potential problems through observation in the field.<\/li><li>Must be able to work 12-hour shifts for an extended day period during plant outages.<\/li><li>Must have a telephone and be open to call outs.<\/li><li>Proven self-direction and leadership abilities.<\/li><li>Good analytical and problem-solving skills.<\/li><li>Ability to prioritize and manage multiple tasks\/projects and meeting all required deadlines.<\/li><li>Must be a team player who works well with others.<\/li><li>Must be open minded, willing to learn, and receptive to change.<\/li><li>Display strong record of attendance reliability.<\/li><li>Must be able to effectively communicate and interact with supervisors and peers.<\/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 possess basic computer skills on how to use MS Office products and SAP.<\/li><li>Ability to read, write, and interpret documents such as work orders, blueprints, mechanical drawings, safety rules, standard operating procedures, maintenance instructions, and procedural manuals.<\/li><li>Knowledgeable of current environmental regulations and practices as they relate to the lime industry.<\/li><\/ul>\n<p><\/p>\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><\/ul>\n<p>\u00b7    &nbsp; Must be physically capable of accessing all plant locations<\/p>\n<p>\u00b7    &nbsp; Access all areas within a site which could include heights of 150 feet, confined spaces, climbing ladders or stairs, and accessing tunnels<\/p>\n<p>\u00b7    &nbsp; Will be working at times in covered environment but mainly in a lime\/mineral environment<\/p>\n<p>\u00b7&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; 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<\/p>\n<p>\u00b7&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; 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<\/p>\n<p>\u00b7&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; Ability to lift\/carry up to 38 lbs<\/p>\n<p><\/p>\n<p><strong>REQUIRED EDUCATION: <\/strong><\/p>\n<ul><li>High School Diploma or GED Equivalent<\/li><\/ul>\n<p><\/p>\n<p><strong>PREFERRED EDUCATION: <\/strong><\/p>\n<ul><li>&nbsp;Completion of an apprenticeship program, technical program, or equivalent experience in industrial background.<\/li><\/ul>\n<p><\/p>\n<p><strong>REQUIRED EXPERIENCE: <\/strong><\/p>\n<ul><li>3+ years mechanical experience including welding, equipment alignments, equipment troubleshooting, reading of blueprints and mechanical drawings&nbsp;<\/li><li>Candidate must be able to pass an electrical assessment test and have a minimum of 200 hours logged working under the supervision of an Electrician<\/li><\/ul>\n<p><\/p>\n<p><strong>PREFERRED EXPERIENCE: <\/strong><\/p>\n<ul><li>Previous heavy manufacturing maintenance and\/or mining maintenance experience is highly preferred<\/li><\/ul>\n<p><\/p>","post_title":"Maintenance Mechanic","post_link":"https:\/\/turnerstaffing.com\/position\/maintenance-mechanic-2\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Associate","%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; <\/strong>To perform maintenance inspections, repairs and rebuilds on all plant operating equipment. This role is critical to achieving Plant OEE and Equipment Availability goals by elimination of unplanned stops and extended downtimes.&nbsp; Employees in the position are required to participate in company-sponsored training and certification programs to ensure that their job knowledge and skills meet the 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 as well as SQF initiatives at all times.<ul><li>Must complete and document Workplace Inspections in a timely manner.<\/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 be well versed in the installation and maintenance of all types of bearings.<\/li><li>Must possess a good knowledge of:<ul><li>oil and grease seals and their applications.<\/li><li>lubricants and their uses.<\/li><\/ul><\/li><li>Must be able to perform:<ul><li>shaft alignments using precision alignment tools<\/li><li>chain and sprocket installation and alignments<\/li><li>belt and sheave installation and alignment<\/li><li>wiring of low voltage motors up to 600VAC<\/li><li>minor runs\/ repairs to conduit<\/li><li>replacement of receptacles\/ switches<\/li><li>minor maintenance on loaders, haul trucks, drills, forklifts, maintenance, and plant vehicles<\/li><li>preventive maintenance checks and report findings (both verbally and in writing)<\/li><li>post-job inspections to ensure a high level of housekeeping standards<\/li><\/ul><\/li><li>Must be able to install and align all types of new equipment.<\/li><li>Must be able to disassemble and rebuild all types of crushing, screening, and conveying equipment.<\/li><li>Operate extended forklift, forklift, man lift, or maintenance machinery to perform plant and quarry maintenance.<\/li><li>Must have a high level of rigging skills.<\/li><li>Must have experience and expertise in the installation of pneumatic and hydraulic piping systems including the use of proper fittings and connectors.<\/li><li>Must be able to troubleshoot, service and repair:<ul><li>all plant environmental equipment and demonstrate knowledge of baghouse operation<\/li><li>hydraulic\/pneumatics systems<\/li><li>all types of repairs to air compressors presently in service<\/li><\/ul><\/li><li>Ensure maintenance tools are kept in good condition, repaired or replaced when necessary.<\/li><li>Must possess and maintain a complete set of personal hand tools as per the LNA list.<\/li><li>Must be able to operate plant mobile equipment.<\/li><li>Must be proficient in the use of precision measuring tools (micrometers, dial indicators, etc.).<\/li><li>Must be qualified to weld in all four positions (certification).<\/li><li>Must be proficient in all kinds of acetylene cutting and welding.<\/li><li>Should be able to perform thickness testing.<\/li><li>Understanding of thermography and how it is used at the site.<\/li><li>Should have a complete understanding of non-destructive testing.<\/li><li>Should possess knowledge of the CMMS System and be willing to correctly complete work orders and checklists including signing and dating.<\/li><li>Perform maintenance on crushers, conveyor belts, vibrating feeders, screens, elevators, refractory repairs, kilns, fans, dust collectors, coal mills, screws, pumps, pulverizers, and other plant and quarry equipment.<\/li><li>Must display competency in performing basic electrical work safely.<\/li><li>Must possess and understand the use of DOM\u2019s, Meggers, Amp Meters.<\/li><li>MCC Starter trouble shooting to included testing of control transformers, fuse testing\/replacement, overload heater testing\/replacement.<\/li><li>Semi-annually the employee will be required to display safe practices and procedures under the supervision of a Maintenance Supervisor and Electrician or Electrical Supervisor.<\/li><li>The company will allocate time for the individual to further their advancement.<\/li><li>Perform other duties as assigned.<\/li><\/ul><\/li><\/ul>\n<p><\/p>\n<p><strong>Safe Quality Food (SQF)<\/strong><\/p>\n<ul><li>Ensure a SQF workplace and in 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>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 able to work any shift, overtime, be on-call, or work seven days a week including holidays and be flexible to schedule changes.<\/li><li>Industrial background with good troubleshooting skills.<\/li><li>Must be able perform basic mathematical computations.<\/li><li>Ability to detect potential problems through observation in the field.<\/li><li>Must be able to work 12-hour shifts for an extended day period during plant outages.<\/li><li>Must have a telephone and be open to call outs.<\/li><li>Proven self-direction and leadership abilities.<\/li><li>Good analytical and problem-solving skills.<\/li><li>Ability to prioritize and manage multiple tasks\/projects and meeting all required deadlines.<\/li><li>Must be a team player who works well with others.<\/li><li>Must be open minded, willing to learn, and receptive to change.<\/li><li>Display strong record of attendance reliability.<\/li><li>Must be able to effectively communicate and interact with supervisors and peers.<\/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 possess basic computer skills on how to use MS Office products and SAP.<\/li><li>Ability to read, write, and interpret documents such as work orders, blueprints, mechanical drawings, safety rules, standard operating procedures, maintenance instructions, and procedural manuals.<\/li><li>Knowledgeable of current environmental regulations and practices as they relate to the lime industry.<\/li><\/ul>\n<p><\/p>\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><\/ul>\n<p>\u00b7    &nbsp; Must be physically capable of accessing all plant locations<\/p>\n<p>\u00b7    &nbsp; Access all areas within a site which could include heights of 150 feet, confined spaces, climbing ladders or stairs, and accessing tunnels<\/p>\n<p>\u00b7    &nbsp; Will be working at times in covered environment but mainly in a lime\/mineral environment<\/p>\n<p>\u00b7&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; 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<\/p>\n<p>\u00b7&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; 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<\/p>\n<p>\u00b7&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; Ability to lift\/carry up to 38 lbs<\/p>\n<p><\/p>\n<p><strong>REQUIRED EDUCATION: <\/strong><\/p>\n<ul><li>High School Diploma or GED Equivalent<\/li><\/ul>\n<p><\/p>\n<p><strong>PREFERRED EDUCATION: <\/strong><\/p>\n<ul><li>&nbsp;Completion of an apprenticeship program, technical program, or equivalent experience in industrial background.<\/li><\/ul>\n<p><\/p>\n<p><strong>REQUIRED EXPERIENCE: <\/strong><\/p>\n<ul><li>3+ years mechanical experience including welding, equipment alignments, equipment troubleshooting, reading of blueprints and mechanical drawings&nbsp;<\/li><li>Candidate must be able to pass an electrical assessment test and have a minimum of 200 hours logged working under the supervision of an Electrician<\/li><\/ul>\n<p><\/p>\n<p><strong>PREFERRED EXPERIENCE: <\/strong><\/p>\n<ul><li>Previous heavy manufacturing maintenance and\/or mining maintenance experience is highly preferred<\/li><\/ul>\n<p><\/p>","%category%":"Other","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/7740204dc823-maintenance-mechanic","%breezy_id%":"7740204dc823","%breezy_friendly_id%":"7740204dc823-maintenance-mechanic","%breezy_created_date%":"2025-04-22T19:32:20.141Z","%breezy_updated_date%":"2025-07-29T15:51:15.303Z","%_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":2482,"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-05-30T14:04:00.711Z","%_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":"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    Turner Staffing Group is seeking experienced Drill Operators to join our team in Harmony, MN. The ideal candidates will have&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/drill-operator-2\/\" name=\"Drill Operator\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Turner Staffing Group is seeking experienced Drill Operators to join our team in Harmony, MN. The ideal candidates will have&hellip;","address":"Harmony, MN, USA","location":{"lat":"43.5551811","city":"Harmony","state":"MN","country":"United States","lng":"-92.0052837","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/drill-operator-2\/","zoom":19,"extra_fields":{"post_excerpt":"Turner Staffing Group is seeking experienced Drill Operators to join our team in Harmony, MN. The ideal candidates will have&hellip;","post_content":"<p>Turner Staffing Group is seeking experienced Drill Operators to join our team in Harmony, MN. The ideal candidates will have hands-on experience operating drilling equipment. The role involves operating drilling rigs to support construction 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\/construction 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>","post_title":"Drill Operator","post_link":"https:\/\/turnerstaffing.com\/position\/drill-operator-2\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Mid Level","%location_country%":"United States","%location_city%":"Harmony","%location_state_id%":"MN","%location_state_name%":"Minnesota","%location_city_state%":"Harmony, MN","%education%":"Unspecified","%department%":"","%description%":"<p>Turner Staffing Group is seeking experienced Drill Operators to join our team in Harmony, MN. The ideal candidates will have hands-on experience operating drilling equipment. The role involves operating drilling rigs to support construction 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\/construction 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>","%category%":"Operations","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/4d5be92706c4-drill-operator","%breezy_id%":"4d5be92706c4","%breezy_friendly_id%":"4d5be92706c4-drill-operator","%breezy_created_date%":"2025-05-29T19:22:32.544Z","%breezy_updated_date%":"2025-06-24T16:13:34.144Z","%_wpgmp_location_city%":"Harmony","%_wpgmp_location_state%":"MN","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Harmony, MN, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"43.5551811","%_wpgmp_metabox_longitude%":"-92.0052837","%rank_math_internal_links_processed%":"1"}},"id":2478,"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%":"2025-06-02T19:01:25.299Z","%_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-7\/\" 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":"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\/haul-truck-driver-7\/","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>The schedule would be 7 days per week 10 hour shifts. Every 3 weeks you get a 3 day weekend.<\/li><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-7\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Associate","%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><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>The schedule would be 7 days per week 10 hour shifts. Every 3 weeks you get a 3 day weekend.<\/li><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\/bb8909986665-haul-truck-driver","%breezy_id%":"bb8909986665","%breezy_friendly_id%":"bb8909986665-haul-truck-driver","%breezy_created_date%":"2025-05-29T13:52:45.402Z","%breezy_updated_date%":"2025-05-29T13:55:56.800Z","%_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":2477,"infowindow_disable":false},{"source":"post","title":"Mining Project Manager &#8211; Traveling","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Mining Project Manager &#8211; Traveling\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Turner Mining Group &#8211; Traveling Project Manager&nbsp; A challenging and rewarding opportunity for a senior project manager with experience in&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/project-manager-traveling\/\" name=\"Mining Project Manager &#8211; Traveling\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Turner Mining Group &#8211; Traveling Project Manager&nbsp; A challenging and rewarding opportunity for a senior project manager with experience in&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-traveling\/","zoom":19,"extra_fields":{"post_excerpt":"Turner Mining Group &#8211; Traveling Project Manager&nbsp; A challenging and rewarding opportunity for a senior project manager with experience in&hellip;","post_content":"<p><strong><u>Turner Mining Group - Traveling 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 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,&nbsp;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>Turner Mining Group&nbsp;offers a competitive salary, an excellent work culture, career advancement opportunities. Turner Mining Group&nbsp;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":"Mining Project Manager &#8211; Traveling","post_link":"https:\/\/turnerstaffing.com\/position\/project-manager-traveling\/","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%":"Mining","%description%":"<p><strong><u>Turner Mining Group - Traveling 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 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,&nbsp;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>Turner Mining Group&nbsp;offers a competitive salary, an excellent work culture, career advancement opportunities. Turner Mining Group&nbsp;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\/c35476423677-mining-project-manager-traveling","%breezy_id%":"c35476423677","%breezy_friendly_id%":"c35476423677-mining-project-manager-traveling","%breezy_created_date%":"2023-12-19T16:18:54.986Z","%breezy_updated_date%":"2025-07-17T17:32:43.051Z","%_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":2475,"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 Do you love mining? Do you think differently? Are you ready to&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/heavy-equipment-fuel-lube-technician-4\/\" 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 Do you love mining? Do you think differently? Are you ready 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\/heavy-equipment-fuel-lube-technician-4\/","zoom":19,"extra_fields":{"post_excerpt":"Heavy Equipment Fuel &amp; Lube Technician Job Description Do you love mining? Do you think differently? Are you ready to&hellip;","post_content":"<p style=\"color:#000000\"><strong><u>Heavy Equipment Fuel &amp; Lube Technician Job Description<\/u><\/strong><\/p>\n<p style=\"color:#000000\"><span style=\"color:#333333\">Do you love mining? Do you think differently? Are you ready to define the future of this industry?<\/span><\/p>\n<p style=\"color:#000000\"><span style=\"color:#333333\">We\u2019ve been waiting for you! Turner Mining Group is committed to changing the way mining companies do business. We develop our people. We partner with our clients. We believe in win, win, win.<\/span><\/p>\n<p>We are looking for a dynamic and talented professional to fill a <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\">This person will function as a <\/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\"><strong><span style=\"color:#333333\"><\/span><\/strong><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 minor repairs on equipment using tools, machine tools and measuring instruments <\/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 <\/span><span style=\"color:#333333\"> <\/span><\/p>\n<p style=\"color:#000000\"><span style=\"color:#333333\">\u2022 Operate and test equipment <\/span><span style=\"color:#333333\"> <\/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 Fuel &amp; Lube Technician","post_link":"https:\/\/turnerstaffing.com\/position\/heavy-equipment-fuel-lube-technician-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><u>Heavy Equipment Fuel & Lube Technician Job Description<\/u><\/strong><\/p>\n<p style=\"color:#000000;\"><span style=\"color:#333333;\">Do you love mining? Do you think differently? Are you ready to define the future of this industry?<\/span><\/p>\n<p style=\"color:#000000;\"><span style=\"color:#333333;\">We\u2019ve been waiting for you! Turner Mining Group is committed to changing the way mining companies do business. We develop our people. We partner with our clients. We believe in win, win, win.<\/span><\/p>\n<p>We are looking for a dynamic and talented professional to fill a <strong>Fuel & Lube Technician<\/strong> 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 <\/span><strong>Fuel & 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;\"><strong><span style=\"color:#333333;\"><\/span><\/strong><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 minor repairs on equipment using tools, machine tools and measuring instruments <\/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 <\/span><span style=\"color:#333333;\"> <\/span><\/p>\n<p style=\"color:#000000;\"><span style=\"color:#333333;\">\u2022 Operate and test equipment <\/span><span style=\"color:#333333;\"> <\/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\/41d995302733-heavy-equipment-fuel-lube-technician","%breezy_id%":"41d995302733","%breezy_friendly_id%":"41d995302733-heavy-equipment-fuel-lube-technician","%breezy_created_date%":"2022-02-28T23:45:36.000Z","%breezy_updated_date%":"2025-06-06T13:54:18.581Z","%_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":2474,"infowindow_disable":false},{"source":"post","title":"Excavator Operator &#8211; Mining","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Excavator Operator &#8211; Mining\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\/heavy-equipment-operator-6\/\" name=\"Excavator Operator &#8211; Mining\" 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":"Chester, VT, USA","location":{"lat":"43.2628476","city":"Chester","state":"VT","country":"United States","lng":"-72.5951082","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/heavy-equipment-operator-6\/","zoom":19,"extra_fields":{"post_excerpt":"Turner Mining Group \u2013 Heavy Equipment Operator We are looking for a dynamic and talented mining Heavy Equipment Operators for&hellip;","post_content":"<p><strong><u>Turner Mining Group \u2013 Heavy Equipment Operator<\/u><\/strong><\/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":"Excavator Operator &#8211; Mining","post_link":"https:\/\/turnerstaffing.com\/position\/heavy-equipment-operator-6\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Associate","%location_country%":"United States","%location_city%":"Chester","%location_state_id%":"VT","%location_state_name%":"Vermont","%location_city_state%":"Chester, VT","%education%":"Unspecified","%department%":"","%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\/7e22e8e680e4-excavator-operator-mining","%breezy_id%":"7e22e8e680e4","%breezy_friendly_id%":"7e22e8e680e4-excavator-operator-mining","%breezy_created_date%":"2025-05-23T19:01:53.329Z","%breezy_updated_date%":"2025-07-25T12:59:53.697Z","%_wpgmp_location_city%":"Chester","%_wpgmp_location_state%":"VT","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Chester, VT, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"43.2628476","%_wpgmp_metabox_longitude%":"-72.5951082","%rank_math_internal_links_processed%":"1"}},"id":2466,"infowindow_disable":false},{"source":"post","title":"Foreman","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    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\/foreman\/\" name=\"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":"Ludlow, VT, USA","location":{"lat":"43.3960723","city":"Ludlow","state":"VT","country":"United States","lng":"-72.7010471","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/foreman\/","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":"Foreman","post_link":"https:\/\/turnerstaffing.com\/position\/foreman\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Mid Level","%location_country%":"United States","%location_city%":"Ludlow","%location_state_id%":"VT","%location_state_name%":"Vermont","%location_city_state%":"Ludlow, VT","%education%":"Unspecified","%department%":"","%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\/82f750503b3b-foreman","%breezy_id%":"82f750503b3b","%breezy_friendly_id%":"82f750503b3b-foreman","%breezy_created_date%":"2025-05-23T19:05:01.782Z","%breezy_updated_date%":"2025-05-23T19:06:07.085Z","%_wpgmp_location_city%":"Ludlow","%_wpgmp_location_state%":"VT","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Ludlow, VT, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"43.3960723","%_wpgmp_metabox_longitude%":"-72.7010471","%rank_math_internal_links_processed%":"1"}},"id":2467,"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-06-02T19:00:24.211Z","%_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":"Haul Truck Driver &#8211; Mining","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Haul Truck Driver &#8211; Mining\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Turner Mining Group \u2013 Haul Truck Driver We are looking for a dynamic and talented mining Haul Truck Drivers for&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/haul-truck-driver-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 We are looking for a dynamic and talented mining Haul Truck Drivers for&hellip;","address":"Ludlow, VT, USA","location":{"lat":"43.3960723","city":"Ludlow","state":"VT","country":"United States","lng":"-72.7010471","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/haul-truck-driver-3\/","zoom":19,"extra_fields":{"post_excerpt":"Turner Mining Group \u2013 Haul Truck Driver We are looking for a dynamic and talented mining Haul Truck Drivers for&hellip;","post_content":"<p><strong><u>Turner Mining Group \u2013 Haul Truck Driver<\/u><\/strong><\/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.<\/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-3\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Entry Level","%location_country%":"United States","%location_city%":"Ludlow","%location_state_id%":"VT","%location_state_name%":"Vermont","%location_city_state%":"Ludlow, VT","%education%":"Unspecified","%department%":"","%description%":"<p><strong><u>Turner Mining Group \u2013 Haul Truck Driver<\/u><\/strong><\/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.<\/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%":"Other","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/992cfc501849-haul-truck-driver-mining","%breezy_id%":"992cfc501849","%breezy_friendly_id%":"992cfc501849-haul-truck-driver-mining","%breezy_created_date%":"2025-05-23T18:58:47.657Z","%breezy_updated_date%":"2025-06-04T14:22:52.377Z","%_wpgmp_location_city%":"Ludlow","%_wpgmp_location_state%":"VT","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Ludlow, VT, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"43.3960723","%_wpgmp_metabox_longitude%":"-72.7010471","%rank_math_internal_links_processed%":"1"}},"id":2465,"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-05-21T18:52:58.159Z","%_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-05-21T18:54:31.514Z","%_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%":"2025-05-21T18:48:34.894Z","%_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%":"2025-05-21T18:51:21.306Z","%_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":"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\/\" 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\/","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\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\/","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\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\/f14587746e36-general-laborer-mining","%breezy_id%":"f14587746e36","%breezy_friendly_id%":"f14587746e36-general-laborer-mining","%breezy_created_date%":"2024-07-22T18:44:12.342Z","%breezy_updated_date%":"2025-05-20T19:12:56.531Z","%_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":2454,"infowindow_disable":false},{"source":"post","title":"Mining Haul Truck Driver (Mack Truck)","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Mining Haul Truck Driver (Mack Truck)\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Turner Mining Group \u2013 Haul Truck Driver (Mack Truck) We are looking for a dynamic and talented mining Haul Truck&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/mining-haul-truck-driver-mack-truck\/\" name=\"Mining Haul Truck Driver (Mack Truck)\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Turner Mining Group \u2013 Haul Truck Driver (Mack Truck) We are looking for a dynamic and talented mining Haul Truck&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\/mining-haul-truck-driver-mack-truck\/","zoom":19,"extra_fields":{"post_excerpt":"Turner Mining Group \u2013 Haul Truck Driver (Mack Truck) We are looking for a dynamic and talented mining Haul Truck&hellip;","post_content":"<p><strong><u>Turner Mining Group \u2013 Haul Truck Driver (Mack Truck)<\/u><\/strong><br><\/p>\n\n\n<p>We are looking for a dynamic and talented mining Haul Truck Drivers for our fast-growing, forward thinking mining services company!<\/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":"Mining Haul Truck Driver (Mack Truck)","post_link":"https:\/\/turnerstaffing.com\/position\/mining-haul-truck-driver-mack-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%":"High School or equivalent","%department%":"Operations","%description%":"<p><strong><u>Turner Mining Group \u2013 Haul Truck Driver (Mack Truck)<\/u><\/strong><br><\/p>\n\n\n<p>We are looking for a dynamic and talented mining Haul Truck Drivers for our fast-growing, forward thinking mining services company!<\/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%":"Other","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/2ac6991ed2ec-mining-haul-truck-driver-mack-truck","%breezy_id%":"2ac6991ed2ec","%breezy_friendly_id%":"2ac6991ed2ec-mining-haul-truck-driver-mack-truck","%breezy_created_date%":"2024-03-15T17:51:23.610Z","%breezy_updated_date%":"2025-06-11T14:13:50.475Z","%_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":2450,"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-05-16T15:09:19.611Z","%_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%":"2025-05-16T15:08:52.766Z","%_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%":"2025-05-22T19:50:32.302Z","%_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-05-14T23:33:25.347Z","%_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":"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\/\" 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":"Kingman, AZ, USA","location":{"lat":"35.1912977","city":"Kingman","state":"AZ","country":"United States","lng":"-114.0522845","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/project-engineer\/","zoom":19,"extra_fields":{"post_excerpt":"Project Engineer Advisor to Project Management Reports to Project Manager Reporting to the Project Manager, the Project Engineer plays a&hellip;","post_content":"<p><strong><u>Project Engineer<\/u><\/strong><\/p>\n<p><strong>Advisor to Project Management<\/strong><\/p>\n<p><strong>Reports to Project Manager<\/strong><\/p>\n<p>Reporting to the Project Manager, the Project Engineer plays a crucial role in bridging technical mining expertise with mining operations by providing insights through engineering guidance, driving operational efficiency, financial accountability, and long-term project success. This position is responsible for analyzing operational data, preparing engineering designs\/operational GPS support, conducting field data collection, and production forecasting.<\/p>\n<p>By integrating engineering principles, the role provides support for optimizing mining operations, identifying cost-saving opportunities, and evaluating potential efficiency improvements. Additionally, it involves collaboration with Turner Mining Group and client teams, ensuring alignment between corporate objectives, site-level execution, and regulatory compliance.<\/p>\n<p>This role requires a strong operational mindset, familiar with MSHA safety guidelines, industry knowledge, and the ability to analyze complex data into actionable recommendations. With a focus on continuous improvement, efficiency, and project execution, the Project Engineer is integral to enhancing both operational performance and efficiency at Turner Mining Group.<\/p>\n<p><strong><u>Position Responsibilities:<\/u><\/strong><\/p>\n<p><strong>Operational &amp; Technical Analysis<\/strong><\/p>\n<p>\u2022 Review operational reports (cost, safety, production) and analyze data for key trends.<\/p>\n<p>\u2022 Develop and implement continuous improvement initiatives to enhance efficiency and reduce costs.<\/p>\n<p>\u2022 Conduct risk assessments for operational, technical, and financial aspects of mining projects.<\/p>\n<p>\u2022 Collaborate with engineering and operations teams to optimize mine planning, design, and extraction techniques.<\/p>\n<p>\u2022 Develop and track key performance indicators (KPIs) to monitor operational performance and drive improvements.<\/p>\n<p><strong>Mine Engineering &amp; Survey Duties<\/strong><\/p>\n<p>\u2022 Manage fleet management and high precision GPS systems.<\/p>\n<p>\u2022 Develop Drill &amp; Blast pattern, profile, and timing designs and short-range plans.<\/p>\n<p>\u2022 Produce road designs, stockpile and waste storage designs, and others in Hexagon MineSight.<\/p>\n<p>\u2022 Operate survey drones and reconcile results.<\/p>\n<p>\u2022 Analyze FMS and other data for risks and opportunities.<\/p>\n<p>\u2022 Audit and advise client on short range mine plans.<\/p>\n<p><strong>Client &amp; Cross-Functional Collaboration<\/strong><\/p>\n<p>\u2022 Work closely with Turner Mining departments and external stakeholders to define project scopes and execution strategies.<\/p>\n<p>\u2022 Act as a technical link between client technical services and project management to ensure alignment on operational objectives.<\/p>\n<p>\u2022 Participate in knowledge-sharing initiatives, such as internal workshops and training, to support operational and analytical capabilities across teams.<\/p>\n<p>\u2022 Engage with suppliers and service providers to optimize procurement strategies for project operations.<\/p>\n<p><strong>Compliance and Safety Integration<\/strong><\/p>\n<p>\u2022 Ensure that all engineering recommendations align with MSHA safety regulations and industry best practices.<\/p>\n<p>\u2022 Develop and maintain standard operating procedures (SOPs) for operational and safety processes.<\/p>\n<p>\u2022 Provide technical guidance to ensure site compliance with environmental and regulatory requirements.<\/p>\n<p><strong><u>Other duties as required.<\/u><\/strong><\/p>\n<p><strong>The Ideal Candidate:<\/strong><\/p>\n<p><strong>Education and Experience<\/strong><\/p>\n<p>\u2022 Mining or Civil Engineering Degree or related.<\/p>\n<p>\u2022 3 years of mine site engineering or operational experience.<\/p>\n<p>\u2022 Hands-on experience with mining engineering software (Hexagon MineSight preferred or similar).<\/p>\n<p>\u2022 Strong proficiency in MS Office (Word, Excel, PowerPoint, Outlook).<\/p>\n<p>\u2022 Part 107 drone license preferred<\/p>\n<p>\u2022 Procurement and mine accounting experience preferred<\/p>\n<p><strong>Technical and Analytical Skills<\/strong><\/p>\n<p>\u2022 Strong problem-solving and data analysis capabilities.<\/p>\n<p>\u2022 Ability to translate complex engineering data into actionable recommendations.<\/p>\n<p>\u2022 Knowledge of drill &amp; blast design, mine haulage analysis, and GPS fleet management.<\/p>\n<p>\u2022 Familiarity with mine accounting and procurement processes (preferred but not required).<\/p>\n<p><strong>Key Competencies \/ Skills<\/strong><\/p>\n<p>\u2022 Results-oriented with a proactive, problem-solving mindset.<\/p>\n<p>\u2022 Effective communicator, capable of working with cross-functional teams and clients.<\/p>\n<p>\u2022 Ability to work independently and manage multiple priorities in a dynamic environment.<\/p>\n<p>\u2022 Detail-oriented with strong documentation and technical writing skills.<\/p>","post_title":"Project Engineer &#8211; Mining","post_link":"https:\/\/turnerstaffing.com\/position\/project-engineer\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Associate","%location_country%":"United States","%location_city%":"Kingman","%location_state_id%":"AZ","%location_state_name%":"Arizona","%location_city_state%":"Kingman, AZ","%education%":"Bachelor's Degree","%department%":"Mining","%description%":"<p><strong><u>Project Engineer<\/u><\/strong><\/p>\n<p><strong>Advisor to Project Management<\/strong><\/p>\n<p><strong>Reports to Project Manager<\/strong><\/p>\n<p>Reporting to the Project Manager, the Project Engineer plays a crucial role in bridging technical mining expertise with mining operations by providing insights through engineering guidance, driving operational efficiency, financial accountability, and long-term project success. This position is responsible for analyzing operational data, preparing engineering designs\/operational GPS support, conducting field data collection, and production forecasting.<\/p>\n<p>By integrating engineering principles, the role provides support for optimizing mining operations, identifying cost-saving opportunities, and evaluating potential efficiency improvements. Additionally, it involves collaboration with Turner Mining Group and client teams, ensuring alignment between corporate objectives, site-level execution, and regulatory compliance.<\/p>\n<p>This role requires a strong operational mindset, familiar with MSHA safety guidelines, industry knowledge, and the ability to analyze complex data into actionable recommendations. With a focus on continuous improvement, efficiency, and project execution, the Project Engineer is integral to enhancing both operational performance and efficiency at Turner Mining Group.<\/p>\n<p><strong><u>Position Responsibilities:<\/u><\/strong><\/p>\n<p><strong>Operational &amp; Technical Analysis<\/strong><\/p>\n<p>\u2022 Review operational reports (cost, safety, production) and analyze data for key trends.<\/p>\n<p>\u2022 Develop and implement continuous improvement initiatives to enhance efficiency and reduce costs.<\/p>\n<p>\u2022 Conduct risk assessments for operational, technical, and financial aspects of mining projects.<\/p>\n<p>\u2022 Collaborate with engineering and operations teams to optimize mine planning, design, and extraction techniques.<\/p>\n<p>\u2022 Develop and track key performance indicators (KPIs) to monitor operational performance and drive improvements.<\/p>\n<p><strong>Mine Engineering &amp; Survey Duties<\/strong><\/p>\n<p>\u2022 Manage fleet management and high precision GPS systems.<\/p>\n<p>\u2022 Develop Drill &amp; Blast pattern, profile, and timing designs and short-range plans.<\/p>\n<p>\u2022 Produce road designs, stockpile and waste storage designs, and others in Hexagon MineSight.<\/p>\n<p>\u2022 Operate survey drones and reconcile results.<\/p>\n<p>\u2022 Analyze FMS and other data for risks and opportunities.<\/p>\n<p>\u2022 Audit and advise client on short range mine plans.<\/p>\n<p><strong>Client &amp; Cross-Functional Collaboration<\/strong><\/p>\n<p>\u2022 Work closely with Turner Mining departments and external stakeholders to define project scopes and execution strategies.<\/p>\n<p>\u2022 Act as a technical link between client technical services and project management to ensure alignment on operational objectives.<\/p>\n<p>\u2022 Participate in knowledge-sharing initiatives, such as internal workshops and training, to support operational and analytical capabilities across teams.<\/p>\n<p>\u2022 Engage with suppliers and service providers to optimize procurement strategies for project operations.<\/p>\n<p><strong>Compliance and Safety Integration<\/strong><\/p>\n<p>\u2022 Ensure that all engineering recommendations align with MSHA safety regulations and industry best practices.<\/p>\n<p>\u2022 Develop and maintain standard operating procedures (SOPs) for operational and safety processes.<\/p>\n<p>\u2022 Provide technical guidance to ensure site compliance with environmental and regulatory requirements.<\/p>\n<p><strong><u>Other duties as required.<\/u><\/strong><\/p>\n<p><strong>The Ideal Candidate:<\/strong><\/p>\n<p><strong>Education and Experience<\/strong><\/p>\n<p>\u2022 Mining or Civil Engineering Degree or related.<\/p>\n<p>\u2022 3 years of mine site engineering or operational experience.<\/p>\n<p>\u2022 Hands-on experience with mining engineering software (Hexagon MineSight preferred or similar).<\/p>\n<p>\u2022 Strong proficiency in MS Office (Word, Excel, PowerPoint, Outlook).<\/p>\n<p>\u2022 Part 107 drone license preferred<\/p>\n<p>\u2022 Procurement and mine accounting experience preferred<\/p>\n<p><strong>Technical and Analytical Skills<\/strong><\/p>\n<p>\u2022 Strong problem-solving and data analysis capabilities.<\/p>\n<p>\u2022 Ability to translate complex engineering data into actionable recommendations.<\/p>\n<p>\u2022 Knowledge of drill &amp; blast design, mine haulage analysis, and GPS fleet management.<\/p>\n<p>\u2022 Familiarity with mine accounting and procurement processes (preferred but not required).<\/p>\n<p><strong>Key Competencies \/ Skills<\/strong><\/p>\n<p>\u2022 Results-oriented with a proactive, problem-solving mindset.<\/p>\n<p>\u2022 Effective communicator, capable of working with cross-functional teams and clients.<\/p>\n<p>\u2022 Ability to work independently and manage multiple priorities in a dynamic environment.<\/p>\n<p>\u2022 Detail-oriented with strong documentation and technical writing skills.<\/p>","%category%":"Operations","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/00b9cc6c3510-project-engineer-mining","%breezy_id%":"00b9cc6c3510","%breezy_friendly_id%":"00b9cc6c3510-project-engineer-mining","%breezy_created_date%":"2025-02-17T21:52:34.180Z","%breezy_updated_date%":"2025-08-11T14:08:58.296Z","%_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":2437,"infowindow_disable":false},{"source":"post","title":"Regional Project Manager- Water Resources","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Regional Project Manager- Water Resources\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Position Overview: We are seeking an experienced and highly motivated Regional Project Manager to lead and manage water resources infrastructure&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/regional-project-manager-water-resources\/\" name=\"Regional Project Manager- Water Resources\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Position Overview: We are seeking an experienced and highly motivated Regional Project Manager to lead and manage water resources infrastructure&hellip;","address":"Knoxville, TN, USA","location":{"lat":"35.965266","city":"Knoxville","state":"TN","country":"United States","lng":"-83.923304","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/regional-project-manager-water-resources\/","zoom":19,"extra_fields":{"post_excerpt":"Position Overview: We are seeking an experienced and highly motivated Regional Project Manager to lead and manage water resources infrastructure&hellip;","post_content":"<h3><strong>Position Overview:<\/strong><\/h3>\n<p>We are seeking an experienced and highly motivated <strong>Regional Project Manager<\/strong> to lead and manage water resources infrastructure projects throughout the U.S., with a primary focus on reservoirs, dams, levees, canals, and impoundments. Based in Knoxville, TN, the successful candidate will play a critical role in planning, executing, and delivering multi-disciplinary projects on time, within scope, and on budget while ensuring regulatory compliance and client satisfaction.<\/p>\n<h3><strong>Key Responsibilities:<\/strong><\/h3>\n<ul>\n<li>\n<p>Manage the full lifecycle of water resource projects including planning, design, permitting, construction, and closeout.<\/p>\n<\/li>\n<li>\n<p>Lead project teams consisting of engineers, geologists, environmental scientists, and construction professionals.<\/p>\n<\/li>\n<li>\n<p>Oversee project budgeting, scheduling, resource allocation, and risk management.<\/p>\n<\/li>\n<li>\n<p>Ensure all projects comply with federal, state, and local environmental and safety regulations (e.g., USACE, FEMA, TDEC).<\/p>\n<\/li>\n<li>\n<p>Serve as the primary point of contact for clients, stakeholders, contractors, and regulatory agencies.<\/p>\n<\/li>\n<li>\n<p>Prepare and present technical reports, proposals, and project updates for both internal and external stakeholders.<\/p>\n<\/li>\n<li>\n<p>Coordinate with local, regional, and federal agencies on permitting and compliance activities.<\/p>\n<\/li>\n<li>\n<p>Mentor and support junior project staff and promote a culture of collaboration, innovation, and continuous improvement.<\/p>\n<\/li>\n<\/ul>\n<h3><strong>Required Qualifications:<\/strong><\/h3>\n<ul>\n<li>\n<p>Bachelor\u2019s degree in Civil Engineering, Environmental Engineering, Water Resources Engineering, or related field (Master\u2019s preferred).<\/p>\n<\/li>\n<li>\n<p>Professional Engineer (P.E.) license required; eligibility for licensure in Tennessee within 6 months preferred.<\/p>\n<\/li>\n<li>\n<p>Minimum 8 years of experience managing civil infrastructure projects related to water resources.<\/p>\n<\/li>\n<li>\n<p>Proven experience with projects involving dams, levees, reservoirs, canals, and impoundments.<\/p>\n<\/li>\n<li>\n<p>Strong understanding of hydrologic and hydraulic modeling, geotechnical assessments, and construction management.<\/p>\n<\/li>\n<li>\n<p>Familiarity with relevant codes and guidelines (FEMA, USACE, NRCS, FERC, etc.).<\/p>\n<\/li>\n<li>\n<p>Excellent communication, leadership, and organizational skills.<\/p>\n<\/li>\n<li>\n<p>Willingness to travel within the region as project demands dictate.<\/p>\n<\/li>\n<\/ul>\n<h3><strong>Preferred Skills:<\/strong><\/h3>\n<ul>\n<li>\n<p>PMP Certification or formal project management training.<\/p>\n<\/li>\n<li>\n<p>Experience with design-build or CMAR project delivery methods.<\/p>\n<\/li>\n<li>\n<p>Proficiency in project management software (e.g., MS Project, Primavera) and design tools (e.g., AutoCAD, HEC-RAS, Civil 3D).<\/p>\n<\/li>\n<li>\n<p>Knowledge of sustainable water management practices and resiliency planning.<\/p><\/li><\/ul>","post_title":"Regional Project Manager- Water Resources","post_link":"https:\/\/turnerstaffing.com\/position\/regional-project-manager-water-resources\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Senior","%location_country%":"United States","%location_city%":"Knoxville","%location_state_id%":"TN","%location_state_name%":"Tennessee","%location_city_state%":"Knoxville, TN","%education%":"Bachelor's Degree","%department%":"","%description%":"<h3><strong>Position Overview:<\/strong><\/h3>\n<p>We are seeking an experienced and highly motivated <strong>Regional Project Manager<\/strong> to lead and manage water resources infrastructure projects throughout the U.S., with a primary focus on reservoirs, dams, levees, canals, and impoundments. Based in Knoxville, TN, the successful candidate will play a critical role in planning, executing, and delivering multi-disciplinary projects on time, within scope, and on budget while ensuring regulatory compliance and client satisfaction.<\/p>\n<h3><strong>Key Responsibilities:<\/strong><\/h3>\n<ul>\n<li>\n<p>Manage the full lifecycle of water resource projects including planning, design, permitting, construction, and closeout.<\/p>\n<\/li>\n<li>\n<p>Lead project teams consisting of engineers, geologists, environmental scientists, and construction professionals.<\/p>\n<\/li>\n<li>\n<p>Oversee project budgeting, scheduling, resource allocation, and risk management.<\/p>\n<\/li>\n<li>\n<p>Ensure all projects comply with federal, state, and local environmental and safety regulations (e.g., USACE, FEMA, TDEC).<\/p>\n<\/li>\n<li>\n<p>Serve as the primary point of contact for clients, stakeholders, contractors, and regulatory agencies.<\/p>\n<\/li>\n<li>\n<p>Prepare and present technical reports, proposals, and project updates for both internal and external stakeholders.<\/p>\n<\/li>\n<li>\n<p>Coordinate with local, regional, and federal agencies on permitting and compliance activities.<\/p>\n<\/li>\n<li>\n<p>Mentor and support junior project staff and promote a culture of collaboration, innovation, and continuous improvement.<\/p>\n<\/li>\n<\/ul>\n<h3><strong>Required Qualifications:<\/strong><\/h3>\n<ul>\n<li>\n<p>Bachelor\u2019s degree in Civil Engineering, Environmental Engineering, Water Resources Engineering, or related field (Master\u2019s preferred).<\/p>\n<\/li>\n<li>\n<p>Professional Engineer (P.E.) license required; eligibility for licensure in Tennessee within 6 months preferred.<\/p>\n<\/li>\n<li>\n<p>Minimum 8 years of experience managing civil infrastructure projects related to water resources.<\/p>\n<\/li>\n<li>\n<p>Proven experience with projects involving dams, levees, reservoirs, canals, and impoundments.<\/p>\n<\/li>\n<li>\n<p>Strong understanding of hydrologic and hydraulic modeling, geotechnical assessments, and construction management.<\/p>\n<\/li>\n<li>\n<p>Familiarity with relevant codes and guidelines (FEMA, USACE, NRCS, FERC, etc.).<\/p>\n<\/li>\n<li>\n<p>Excellent communication, leadership, and organizational skills.<\/p>\n<\/li>\n<li>\n<p>Willingness to travel within the region as project demands dictate.<\/p>\n<\/li>\n<\/ul>\n<h3><strong>Preferred Skills:<\/strong><\/h3>\n<ul>\n<li>\n<p>PMP Certification or formal project management training.<\/p>\n<\/li>\n<li>\n<p>Experience with design-build or CMAR project delivery methods.<\/p>\n<\/li>\n<li>\n<p>Proficiency in project management software (e.g., MS Project, Primavera) and design tools (e.g., AutoCAD, HEC-RAS, Civil 3D).<\/p>\n<\/li>\n<li>\n<p>Knowledge of sustainable water management practices and resiliency planning.<\/p><\/li><\/ul>","%category%":"Management","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/6120f68a4487-regional-project-manager-water-resources","%breezy_id%":"6120f68a4487","%breezy_friendly_id%":"6120f68a4487-regional-project-manager-water-resources","%breezy_created_date%":"2025-05-12T16:16:34.371Z","%breezy_updated_date%":"2025-05-12T16:17:08.188Z","%_wpgmp_location_city%":"Knoxville","%_wpgmp_location_state%":"TN","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Knoxville, TN, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"35.965266","%_wpgmp_metabox_longitude%":"-83.923304","%rank_math_internal_links_processed%":"1"}},"id":2435,"infowindow_disable":false},{"source":"post","title":"Excavator Operator","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Excavator Operator\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Job Title: Excavator Operator Location: Kershaw, South Carolina About Us: Turner Staffing Group is a leading staffing agency dedicated to&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/excavator-operator\/\" name=\"Excavator Operator\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Job Title: Excavator Operator Location: Kershaw, South Carolina About Us: Turner Staffing Group is a leading staffing agency dedicated to&hellip;","address":"Kershaw, SC, USA","location":{"lat":"34.5518201","city":"Kershaw","state":"SC","country":"United States","lng":"-80.5836836","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/excavator-operator\/","zoom":19,"extra_fields":{"post_excerpt":"Job Title: Excavator Operator Location: Kershaw, South Carolina About Us: Turner Staffing Group is a leading staffing agency dedicated to&hellip;","post_content":"<p><strong>Job Title: Excavator Operator<\/strong><br><\/p>\n<p><strong>Location:<\/strong> Kershaw, South Carolina<\/p>\n<p><strong>About Us:<\/strong>\nTurner Staffing Group is a leading staffing agency dedicated to connecting skilled professionals with rewarding opportunities. We are proud to partner with a reputable mining company located in Kershaw, South Carolina. Our client is seeking a skilled and experienced Excavator Operator to join their team and contribute to their ongoing success in the mining industry.<\/p>\n<p><strong>Job Description:<\/strong><\/p>\n<p>As an Excavator Operator, you will play a critical role in the efficient operation of our mining operations in Kershaw, South Carolina. Operating heavy equipment with precision and safety, you will be responsible for excavating and moving materials to facilitate mining activities and achieve production targets.<\/p>\n<p><strong>Key Responsibilities:<\/strong><\/p>\n<ol><li><strong>Equipment Operation:<\/strong> Operate hydraulic excavators with precision and efficiency to excavate, load, and transport materials within the mining site. Familiarity with various excavator attachments and equipment configurations is preferred.<\/li><li><strong>Safety Compliance:<\/strong> Adhere to all safety protocols and procedures to ensure a safe working environment for yourself and others. Conduct pre-operation inspections and routine maintenance checks on equipment to identify and address any safety hazards or mechanical issues.<\/li><li><strong>Material Handling:<\/strong> Utilize excavators to move, load, and unload materials such as overburden, ore, and waste rock. Coordinate with other team members to optimize material handling processes and minimize downtime.<\/li><li><strong>Production Support:<\/strong> Support mining operations by excavating trenches, stockpiling materials, and shaping terrain as required. Work collaboratively with supervisors and other operators to achieve production targets and meet project deadlines.<\/li><li><strong>Quality Control:<\/strong> Maintain a high level of accuracy and precision in material handling activities to ensure the quality and integrity of mined materials. Follow established procedures for separating and stockpiling different grades of materials as required.<\/li><li><strong>Equipment Maintenance:<\/strong> Perform routine maintenance tasks on excavators, including greasing, lubricating, and replacing worn parts. Report any mechanical issues or equipment malfunctions to the maintenance team for timely repairs.<\/li><\/ol>\n<p><strong>Qualifications:<\/strong><\/p>\n<ul><li>Previous experience operating hydraulic excavators in a mining or heavy construction environment is required.<\/li><li>Proficiency in operating excavators with precision and accuracy, including the ability to manipulate attachments and control machine functions effectively.<\/li><li>Strong commitment to safety and adherence to safety regulations and best practices.<\/li><li>Mechanical aptitude and the ability to perform routine maintenance tasks on equipment.<\/li><li>Excellent hand-eye coordination, spatial awareness, and depth perception.<\/li><li>Willingness to work outdoors in various weather conditions and physically demanding environments.<\/li><\/ul>","post_title":"Excavator Operator","post_link":"https:\/\/turnerstaffing.com\/position\/excavator-operator\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Associate","%location_country%":"United States","%location_city%":"Kershaw","%location_state_id%":"SC","%location_state_name%":"South Carolina","%location_city_state%":"Kershaw, SC","%education%":"High School or equivalent","%department%":"Operations","%description%":"<p><strong>Job Title: Excavator Operator<\/strong><br><\/p>\n<p><strong>Location:<\/strong> Kershaw, South Carolina<\/p>\n<p><strong>About Us:<\/strong>\nTurner Staffing Group is a leading staffing agency dedicated to connecting skilled professionals with rewarding opportunities. We are proud to partner with a reputable mining company located in Kershaw, South Carolina. Our client is seeking a skilled and experienced Excavator Operator to join their team and contribute to their ongoing success in the mining industry.<\/p>\n<p><strong>Job Description:<\/strong><\/p>\n<p>As an Excavator Operator, you will play a critical role in the efficient operation of our mining operations in Kershaw, South Carolina. Operating heavy equipment with precision and safety, you will be responsible for excavating and moving materials to facilitate mining activities and achieve production targets.<\/p>\n<p><strong>Key Responsibilities:<\/strong><\/p>\n<ol><li><strong>Equipment Operation:<\/strong> Operate hydraulic excavators with precision and efficiency to excavate, load, and transport materials within the mining site. Familiarity with various excavator attachments and equipment configurations is preferred.<\/li><li><strong>Safety Compliance:<\/strong> Adhere to all safety protocols and procedures to ensure a safe working environment for yourself and others. Conduct pre-operation inspections and routine maintenance checks on equipment to identify and address any safety hazards or mechanical issues.<\/li><li><strong>Material Handling:<\/strong> Utilize excavators to move, load, and unload materials such as overburden, ore, and waste rock. Coordinate with other team members to optimize material handling processes and minimize downtime.<\/li><li><strong>Production Support:<\/strong> Support mining operations by excavating trenches, stockpiling materials, and shaping terrain as required. Work collaboratively with supervisors and other operators to achieve production targets and meet project deadlines.<\/li><li><strong>Quality Control:<\/strong> Maintain a high level of accuracy and precision in material handling activities to ensure the quality and integrity of mined materials. Follow established procedures for separating and stockpiling different grades of materials as required.<\/li><li><strong>Equipment Maintenance:<\/strong> Perform routine maintenance tasks on excavators, including greasing, lubricating, and replacing worn parts. Report any mechanical issues or equipment malfunctions to the maintenance team for timely repairs.<\/li><\/ol>\n<p><strong>Qualifications:<\/strong><\/p>\n<ul><li>Previous experience operating hydraulic excavators in a mining or heavy construction environment is required.<\/li><li>Proficiency in operating excavators with precision and accuracy, including the ability to manipulate attachments and control machine functions effectively.<\/li><li>Strong commitment to safety and adherence to safety regulations and best practices.<\/li><li>Mechanical aptitude and the ability to perform routine maintenance tasks on equipment.<\/li><li>Excellent hand-eye coordination, spatial awareness, and depth perception.<\/li><li>Willingness to work outdoors in various weather conditions and physically demanding environments.<\/li><\/ul>","%category%":"Operations","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/99547b2c6f0d-excavator-operator","%breezy_id%":"99547b2c6f0d","%breezy_friendly_id%":"99547b2c6f0d-excavator-operator","%breezy_created_date%":"2024-04-10T20:48:53.746Z","%breezy_updated_date%":"2025-05-20T19:12:13.785Z","%_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":2436,"infowindow_disable":false},{"source":"post","title":"Industrial Electrician","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Industrial Electrician\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    A strong team member will perform duties including but not limited to electrician and all aspects of mechanical maintenance. Team&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/industrial-electrician-3\/\" name=\"Industrial Electrician\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"A strong team member will perform duties including but not limited to electrician and all aspects of mechanical maintenance. Team&hellip;","address":"Burnet, TX, USA","location":{"lat":"30.7582376","city":"Burnet","state":"TX","country":"United States","lng":"-98.2283585","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/industrial-electrician-3\/","zoom":19,"extra_fields":{"post_excerpt":"A strong team member will perform duties including but not limited to electrician and all aspects of mechanical maintenance. Team&hellip;","post_content":"<p>A strong team member will perform duties including but not limited to electrician and all aspects of mechanical maintenance. Team member will be able to troubleshoot issues to ensure all electrical and mechanical components are in good working order throughout the plant.<\/p>\n<p><strong>RESPONSIBILITIES &amp; EXPECTATIONS:<\/strong><\/p>\n<p><strong>Electrical<\/strong><\/p>\n<ul><li>Install and align electrical motors.<\/li><li>Set up &amp; troubleshoot A\/C drives.<\/li><li>Perform routine mechanical tasks. E.g. Replacement of bearings, idlers, dust collector bags, gearboxes, and drive belts will be required.<\/li><li>Able to troubleshoot control circuits with limited supervision.<\/li><li>Perform basic electrical calculations.<\/li><li>Perform tasks with all electrical test equipment (multi meters, meggers, current generators, Hart communicator, etc.)<\/li><li>Fabricate and install conduit.<\/li><li>Perform soldering operations.<\/li><li>Troubleshoot and maintain motor control circuits.<\/li><\/ul>\n<p><strong>Maintenance<\/strong><\/p>\n<ul><li>Must be able to disassemble and rebuild all types of crushing, screening, and conveying equipment.<\/li><li>Able to use equipment manuals, parts lists or blueprints to properly install, repair, or order parts.<\/li><li>Troubleshoot and perform repairs to hydraulic systems and pneumatic systems.<\/li><li>Troubleshoot and maintain variable speed drives.<\/li><li>Troubleshoot kiln instrumentation<\/li><li>Initiate work orders as required.<\/li><li>Ensure all inventory parts are correctly charged from warehouse.<\/li><li>Ensure all parts are available before starting job.<\/li><li>Operate extended forklift, manlift, or maintenance machinery to perform plant maintenance.<\/li><li>Perform preventive maintenance checks and report findings verbally and in writing<\/li><li>Navigate and understand NEC code book.<\/li><li>Assist with routine mechanical tasks. E.g. Replacement of bearings, idlers, dust collector bags, gearboxes, and drive belts will be required.<\/li><li>Initiate work orders as required.<\/li><li>Operate extended forklift, manlift, or maintenance machinery to perform plant maintenance.<\/li><\/ul>\n<p><strong>Training<\/strong><\/p>\n<ul><li>Willing to upgrade skills by participating in vendor and company-designated training.<\/li><li>Process knowledge of the CMMS System to ensure that work orders and checklists are complete accurately.<\/li><\/ul>\n<p><strong>Safety<\/strong><\/p>\n<ul><li>Comply with company, state, and governmental health and safety regulations at all times.<\/li><li>Complete and document Workplace Inspections in a timely manner.<\/li><li>Ensure maintenance tools are kept in good condition, repaired or replaced when necessary.<\/li><\/ul>\n<p><strong>ATTRIBUTES:<\/strong><\/p>\n<ul><li>Industrial background with good troubleshooting skills.<\/li><li>Must be able perform basic mathematical computations<\/li><li>Ability to detect potential problems through observation in the field.<\/li><li>Must be able to work shift work, seven days a week including holidays and be flexible to schedule changes.<\/li><li>Must have a telephone and be open to callouts.<\/li><li>Self-Motivated and must be able to work independently.<\/li><li>Good decision-making skills regarding safety.<\/li><li>Must be able to tolerate working outside in severe weather conditions as well as exposure to high temperature, noise, and dust.<\/li><li>Knowledge of basic computer skills.<\/li><li>Ability to read, write, and interpret documents such as work orders, blueprints, mechanical drawings, safety rules, standard operating procedures, maintenance instructions, and procedural manuals.<\/li><li>Knowledgeable of current environmental regulations and practices as they relate to the lime industry.<\/li><li>Must perform all tasks in a timely and efficient manner.<\/li><\/ul>\n<p><strong>PHYSICAL DEMANDS INCLUDE, BUT ARE NOT LIMITED TO:<\/strong><\/p>\n<ul><li>Must be able to tolerate working outside in severe weather conditions as well as exposure to high temperature, noise, and dust.<\/li><li>Must be able to access all plant locations and perform the essential job duties of this position. This could include heights of 190 feet, confined spaces, climbing ladders or stairs, and accessing tunnels<\/li><li>Ability to occasionally lift\/carry 50 pounds..<\/li><li>Previous experience operating heavy equipment is desired.<\/li><\/ul>\n<p><strong>REQUIRED EDUCATION:<\/strong><\/p>\n<ul><li>High School Diploma or GED equivalent.<\/li><\/ul>\n<p><strong>REQUIRED EXPERIENCE:<\/strong><\/p>\n<ul><li>5+ years electrical experience, and demonstration of safe work practices. Basic electrical and safety knowledge required.<\/li><\/ul>\n<p><strong>PREFERRED EXPERIENCE:<\/strong><\/p>\n<ul><li>Completion of an apprenticeship program, technical program, or equivalent experience in industrial background.<\/li><\/ul>","post_title":"Industrial Electrician","post_link":"https:\/\/turnerstaffing.com\/position\/industrial-electrician-3\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Mid Level","%location_country%":"United States","%location_city%":"Burnet","%location_state_id%":"TX","%location_state_name%":"Texas","%location_city_state%":"Burnet, TX","%education%":"High School or equivalent","%department%":"","%description%":"<p>A strong team member will perform duties including but not limited to electrician and all aspects of mechanical maintenance. Team member will be able to troubleshoot issues to ensure all electrical and mechanical components are in good working order throughout the plant.<\/p>\n<p><strong>RESPONSIBILITIES &amp; EXPECTATIONS:<\/strong><\/p>\n<p><strong>Electrical<\/strong><\/p>\n<ul><li>Install and align electrical motors.<\/li><li>Set up &amp; troubleshoot A\/C drives.<\/li><li>Perform routine mechanical tasks. E.g. Replacement of bearings, idlers, dust collector bags, gearboxes, and drive belts will be required.<\/li><li>Able to troubleshoot control circuits with limited supervision.<\/li><li>Perform basic electrical calculations.<\/li><li>Perform tasks with all electrical test equipment (multi meters, meggers, current generators, Hart communicator, etc.)<\/li><li>Fabricate and install conduit.<\/li><li>Perform soldering operations.<\/li><li>Troubleshoot and maintain motor control circuits.<\/li><\/ul>\n<p><strong>Maintenance<\/strong><\/p>\n<ul><li>Must be able to disassemble and rebuild all types of crushing, screening, and conveying equipment.<\/li><li>Able to use equipment manuals, parts lists or blueprints to properly install, repair, or order parts.<\/li><li>Troubleshoot and perform repairs to hydraulic systems and pneumatic systems.<\/li><li>Troubleshoot and maintain variable speed drives.<\/li><li>Troubleshoot kiln instrumentation<\/li><li>Initiate work orders as required.<\/li><li>Ensure all inventory parts are correctly charged from warehouse.<\/li><li>Ensure all parts are available before starting job.<\/li><li>Operate extended forklift, manlift, or maintenance machinery to perform plant maintenance.<\/li><li>Perform preventive maintenance checks and report findings verbally and in writing<\/li><li>Navigate and understand NEC code book.<\/li><li>Assist with routine mechanical tasks. E.g. Replacement of bearings, idlers, dust collector bags, gearboxes, and drive belts will be required.<\/li><li>Initiate work orders as required.<\/li><li>Operate extended forklift, manlift, or maintenance machinery to perform plant maintenance.<\/li><\/ul>\n<p><strong>Training<\/strong><\/p>\n<ul><li>Willing to upgrade skills by participating in vendor and company-designated training.<\/li><li>Process knowledge of the CMMS System to ensure that work orders and checklists are complete accurately.<\/li><\/ul>\n<p><strong>Safety<\/strong><\/p>\n<ul><li>Comply with company, state, and governmental health and safety regulations at all times.<\/li><li>Complete and document Workplace Inspections in a timely manner.<\/li><li>Ensure maintenance tools are kept in good condition, repaired or replaced when necessary.<\/li><\/ul>\n<p><strong>ATTRIBUTES:<\/strong><\/p>\n<ul><li>Industrial background with good troubleshooting skills.<\/li><li>Must be able perform basic mathematical computations<\/li><li>Ability to detect potential problems through observation in the field.<\/li><li>Must be able to work shift work, seven days a week including holidays and be flexible to schedule changes.<\/li><li>Must have a telephone and be open to callouts.<\/li><li>Self-Motivated and must be able to work independently.<\/li><li>Good decision-making skills regarding safety.<\/li><li>Must be able to tolerate working outside in severe weather conditions as well as exposure to high temperature, noise, and dust.<\/li><li>Knowledge of basic computer skills.<\/li><li>Ability to read, write, and interpret documents such as work orders, blueprints, mechanical drawings, safety rules, standard operating procedures, maintenance instructions, and procedural manuals.<\/li><li>Knowledgeable of current environmental regulations and practices as they relate to the lime industry.<\/li><li>Must perform all tasks in a timely and efficient manner.<\/li><\/ul>\n<p><strong>PHYSICAL DEMANDS INCLUDE, BUT ARE NOT LIMITED TO:<\/strong><\/p>\n<ul><li>Must be able to tolerate working outside in severe weather conditions as well as exposure to high temperature, noise, and dust.<\/li><li>Must be able to access all plant locations and perform the essential job duties of this position. This could include heights of 190 feet, confined spaces, climbing ladders or stairs, and accessing tunnels<\/li><li>Ability to occasionally lift\/carry 50 pounds..<\/li><li>Previous experience operating heavy equipment is desired.<\/li><\/ul>\n<p><strong>REQUIRED EDUCATION:<\/strong><\/p>\n<ul><li>High School Diploma or GED equivalent.<\/li><\/ul>\n<p><strong>REQUIRED EXPERIENCE:<\/strong><\/p>\n<ul><li>5+ years electrical experience, and demonstration of safe work practices. Basic electrical and safety knowledge required.<\/li><\/ul>\n<p><strong>PREFERRED EXPERIENCE:<\/strong><\/p>\n<ul><li>Completion of an apprenticeship program, technical program, or equivalent experience in industrial background.<\/li><\/ul>","%category%":"Other","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/e3a5e8c20231-industrial-electrician","%breezy_id%":"e3a5e8c20231","%breezy_friendly_id%":"e3a5e8c20231-industrial-electrician","%breezy_created_date%":"2025-02-07T00:56:21.987Z","%breezy_updated_date%":"2025-06-19T18:52:33.397Z","%_wpgmp_location_city%":"Burnet","%_wpgmp_location_state%":"TX","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Burnet, TX, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"30.7582376","%_wpgmp_metabox_longitude%":"-98.2283585","%rank_math_internal_links_processed%":"1"}},"id":2431,"infowindow_disable":false},{"source":"post","title":"Haul Truck Operator &#8211; Mining","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Haul Truck Operator &#8211; Mining\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Job Title:&nbsp;Haul Truck Driver Company:&nbsp;Mining Company (Partnered with Turner Staffing Group) Location:&nbsp;Kershaw, SC Position Type:&nbsp;Full-Time About Us:&nbsp;Turner Staffing Group is&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/haul-truck-operator-mining\/\" name=\"Haul Truck Operator &#8211; Mining\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Job Title:&nbsp;Haul Truck Driver Company:&nbsp;Mining Company (Partnered with Turner Staffing Group) Location:&nbsp;Kershaw, SC Position Type:&nbsp;Full-Time About Us:&nbsp;Turner Staffing Group is&hellip;","address":"Kershaw, SC, USA","location":{"lat":"34.5518201","city":"Kershaw","state":"SC","country":"United States","lng":"-80.5836836","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/haul-truck-operator-mining\/","zoom":19,"extra_fields":{"post_excerpt":"Job Title:&nbsp;Haul Truck Driver Company:&nbsp;Mining Company (Partnered with Turner Staffing Group) Location:&nbsp;Kershaw, SC Position Type:&nbsp;Full-Time About Us:&nbsp;Turner Staffing Group is&hellip;","post_content":"<p><strong>Job Title:<\/strong>&nbsp;Haul Truck Driver<\/p>\n<p><strong>Company:&nbsp;<\/strong>Mining Company (Partnered with Turner Staffing Group)<\/p>\n<p><strong>Location:<\/strong>&nbsp;Kershaw, SC<\/p>\n<p><strong>Position Type:<\/strong>&nbsp;Full-Time<\/p>\n<p><strong>About Us:<\/strong>&nbsp;Turner Staffing Group is proud to partner with a leading Mining Company in Kershaw, SC, dedicated to responsible and sustainable mining practices. Together, we are seeking a skilled and safety-conscious Haul Truck Driver to join the mining operations team. This is an exciting opportunity to contribute to the success of a well-established mining company committed to excellence and environmental stewardship.<\/p>\n<p><strong>Job Overview:<\/strong>&nbsp;As a Haul Truck Driver, you will play a crucial role in the transportation of materials within the mining site, ensuring the safe and efficient movement of material. The ideal candidate will have experience operating large haul trucks, a strong commitment to safety, and the ability to work in a dynamic mining environment.<\/p>\n<p><strong>Responsibilities:<\/strong><\/p>\n<ol><li><strong>Safe Operation of Haul Trucks:<\/strong><ul><li>Operate haul trucks to transport materials within the mining site.<\/li><li>Adhere to all safety protocols and guidelines to ensure a safe working environment.<\/li><\/ul><\/li><li><strong>Material Transportation:<\/strong><ul><li>Load, transport, and unload materials according to project specifications and production schedules.<\/li><li>Communicate effectively with equipment operators and supervisors to coordinate material movement.<\/li><\/ul><\/li><li><strong>Equipment Maintenance:<\/strong><ul><li>Conduct pre-shift inspections on haul trucks and report any issues to the maintenance team.<\/li><li>Ensure routine maintenance tasks are performed to keep equipment in optimal condition.<\/li><\/ul><\/li><li><strong>Safety Compliance:<\/strong><ul><li>Follow safety procedures and guidelines to prevent accidents and injuries.<\/li><li>Participate in safety meetings and training sessions as required.<\/li><\/ul><\/li><li><strong>Record Keeping:<\/strong><ul><li>Maintain accurate records of material transported, distances covered, and fuel consumption.<\/li><li>Report any incidents or accidents promptly.<\/li><\/ul><\/li><\/ol>\n<p><strong>Requirements:<\/strong><\/p>\n<ul><li>Proven experience as a Articulating Haul Truck Driver in a mining or heavy equipment environment.<\/li><li>MSHA certificate preferred.&nbsp;<\/li><li>Knowledge of safe haul truck operation practices.<\/li><li>Ability to work in a physically demanding and outdoor environment.<\/li><li>Strong communication skills and the ability to work as part of a team.<\/li><\/ul>\n<p><strong>Benefits:<\/strong><\/p>\n<ul><li>Competitive salary<\/li><li>Health, dental, and vision insurance<\/li><li>Retirement savings plan<\/li><\/ul>","post_title":"Haul Truck Operator &#8211; Mining","post_link":"https:\/\/turnerstaffing.com\/position\/haul-truck-operator-mining\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Associate","%location_country%":"United States","%location_city%":"Kershaw","%location_state_id%":"SC","%location_state_name%":"South Carolina","%location_city_state%":"Kershaw, SC","%education%":"Unspecified","%department%":"Operations","%description%":"<p><strong>Job Title:<\/strong>&nbsp;Haul Truck Driver<\/p>\n<p><strong>Company:&nbsp;<\/strong>Mining Company (Partnered with Turner Staffing Group)<\/p>\n<p><strong>Location:<\/strong>&nbsp;Kershaw, SC<\/p>\n<p><strong>Position Type:<\/strong>&nbsp;Full-Time<\/p>\n<p><strong>About Us:<\/strong>&nbsp;Turner Staffing Group is proud to partner with a leading Mining Company in Kershaw, SC, dedicated to responsible and sustainable mining practices. Together, we are seeking a skilled and safety-conscious Haul Truck Driver to join the mining operations team. This is an exciting opportunity to contribute to the success of a well-established mining company committed to excellence and environmental stewardship.<\/p>\n<p><strong>Job Overview:<\/strong>&nbsp;As a Haul Truck Driver, you will play a crucial role in the transportation of materials within the mining site, ensuring the safe and efficient movement of material. The ideal candidate will have experience operating large haul trucks, a strong commitment to safety, and the ability to work in a dynamic mining environment.<\/p>\n<p><strong>Responsibilities:<\/strong><\/p>\n<ol><li><strong>Safe Operation of Haul Trucks:<\/strong><ul><li>Operate haul trucks to transport materials within the mining site.<\/li><li>Adhere to all safety protocols and guidelines to ensure a safe working environment.<\/li><\/ul><\/li><li><strong>Material Transportation:<\/strong><ul><li>Load, transport, and unload materials according to project specifications and production schedules.<\/li><li>Communicate effectively with equipment operators and supervisors to coordinate material movement.<\/li><\/ul><\/li><li><strong>Equipment Maintenance:<\/strong><ul><li>Conduct pre-shift inspections on haul trucks and report any issues to the maintenance team.<\/li><li>Ensure routine maintenance tasks are performed to keep equipment in optimal condition.<\/li><\/ul><\/li><li><strong>Safety Compliance:<\/strong><ul><li>Follow safety procedures and guidelines to prevent accidents and injuries.<\/li><li>Participate in safety meetings and training sessions as required.<\/li><\/ul><\/li><li><strong>Record Keeping:<\/strong><ul><li>Maintain accurate records of material transported, distances covered, and fuel consumption.<\/li><li>Report any incidents or accidents promptly.<\/li><\/ul><\/li><\/ol>\n<p><strong>Requirements:<\/strong><\/p>\n<ul><li>Proven experience as a Articulating Haul Truck Driver in a mining or heavy equipment environment.<\/li><li>MSHA certificate preferred.&nbsp;<\/li><li>Knowledge of safe haul truck operation practices.<\/li><li>Ability to work in a physically demanding and outdoor environment.<\/li><li>Strong communication skills and the ability to work as part of a team.<\/li><\/ul>\n<p><strong>Benefits:<\/strong><\/p>\n<ul><li>Competitive salary<\/li><li>Health, dental, and vision insurance<\/li><li>Retirement savings plan<\/li><\/ul>","%category%":"Other","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/006a47caa139-haul-truck-operator-mining","%breezy_id%":"006a47caa139","%breezy_friendly_id%":"006a47caa139-haul-truck-operator-mining","%breezy_created_date%":"2024-02-28T15:08:18.371Z","%breezy_updated_date%":"2025-05-20T19:14:21.374Z","%_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":2422,"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    Summary: The Chief Estimator is responsible for leading the company&#8217;s estimating program, providing both technical and administrative direction to ensure&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/chief-estimator\/\" name=\"Chief Estimator\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Summary: The Chief Estimator is responsible for leading the company&#8217;s estimating program, providing both technical and administrative direction to ensure&hellip;","address":"Knoxville, TN, USA","location":{"lat":"35.965266","city":"Knoxville","state":"TN","country":"United States","lng":"-83.923304","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/chief-estimator\/","zoom":19,"extra_fields":{"post_excerpt":"Summary: The Chief Estimator is responsible for leading the company&#8217;s estimating program, providing both technical and administrative direction to ensure&hellip;","post_content":"<p><strong>Summary:<\/strong><\/p>\n<p>The Chief Estimator is responsible for leading the company's estimating program, providing both technical and administrative direction to ensure corporate objectives are met. This role encompasses managing the estimating department's functions, including operating budgets, staffing, and work assignments, while also playing a crucial role in project bidding and strategy development.<\/p>\n<p><strong>Essential Duties and Responsibilities:<\/strong><\/p>\n<ul>\n <li>Oversee the estimating department's      operations, including budget management, staffing decisions, wage reviews,      and performance evaluations.<\/li>\n <li>Collaborate with corporate and project      management to identify bidding opportunities, define strategies, and      select techniques for project bids.<\/li>\n <li>Prepare and manage the bid schedule,      tracking projects for estimate and proposal preparation from various      sources.<\/li>\n <li>Schedule and lead bid review meetings,      assessing project risks and establishing base wage rates for all estimates      and proposals.<\/li>\n <li>Develop Scope of Work packages for      construction subcontractors and vendors in coordination with the Project      Controls Manager and\/or Operations Support Manager.<\/li>\n <li>Maintain a comprehensive subcontractor      and vendor database, fostering positive relationships with these partners.<\/li>\n <li>Evaluate project requirements for DBE,      Small Business, MBE\/WBE participation, ensuring compliance with good faith      efforts and other regulations.<\/li>\n <li>Review bid forms for completeness and      accuracy, including the analysis of General and Special\/Supplemental      Conditions to appropriately assign costs.<\/li>\n <li>Coordinate scope reviews with the      project management team, ensuring project schedule requirements are fully      understood.<\/li>\n <li>Assign allowances and contingencies to      estimates and cost proposals, reviewing and adjusting final estimate      packages for accuracy before submission.<\/li>\n <li>Participate in presentations to      corporate management and clients, potentially being responsible for      closing sales.<\/li>\n <li>Conduct post-proposal activities,      securely archiving all original cost proposal documents and organizing      material for the project execution team.<\/li>\n <li>Establish and maintain a historical      cost database, tracking \"hit rates\" and other metrics to inform      future bidding strategies.<\/li>\n <li>Provide technical assistance in      negotiating contracts and change orders, and may assist in the preparation      of studies, materials, methods, and cost estimates as required.<\/li>\n<\/ul>\n<p><strong>Supervisory Responsibilities:<\/strong><\/p>\n<ul>\n <li>Form bid teams, assign work, and      monitor the progress of estimates and cost proposals.<\/li>\n <li>Assign attendees for pre-bid meetings      and mentor estimating staff, conducting performance reviews in conjunction      with the Operations Manager and\/or Chief Operations Officer.<\/li>\n <li>Develop and implement training programs      for junior estimators, enhancing their skills and knowledge.<\/li>\n<\/ul>\n<p><strong>Requirements:<\/strong><\/p>\n<ul>\n <li>Exceptional organizational,      supervisory, and decision-making skills, capable of efficiently handling      multiple priorities.<\/li>\n <li>Deep knowledge of construction and      design principles, including extensive estimating experience, construction      planning, and innovative problem-solving techniques.<\/li>\n <li>A thorough understanding of corporate      and industry practices, processes, standards, and their impact on      estimating strategies and techniques, as well as construction contracts.<\/li>\n<\/ul>\n<p><strong>Education and Experience:<\/strong><\/p>\n<ul>\n <li>A four-year engineering degree or an      equivalent combination of technical training and experience, with advanced      management or technical training preferred.<\/li>\n <li>Extensive experience (10 or more years)      in construction estimating and related functions, along with a thorough      knowledge of corporate objectives impacting estimating, strategies,      techniques, and construction contracts.<\/li>\n <li>Must possess excellent organizational,      supervisory, and decision-making\/problem-solving skills.<\/li>\n<\/ul>","post_title":"Chief Estimator","post_link":"https:\/\/turnerstaffing.com\/position\/chief-estimator\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Senior","%location_country%":"United States","%location_city%":"Knoxville","%location_state_id%":"TN","%location_state_name%":"Tennessee","%location_city_state%":"Knoxville, TN","%education%":"Bachelor's Degree","%department%":"","%description%":"<p><strong>Summary:<\/strong><\/p>\n<p>The Chief Estimator is responsible for leading the company's estimating program, providing both technical and administrative direction to ensure corporate objectives are met. This role encompasses managing the estimating department's functions, including operating budgets, staffing, and work assignments, while also playing a crucial role in project bidding and strategy development.<\/p>\n<p><strong>Essential Duties and Responsibilities:<\/strong><\/p>\n<ul>\n <li>Oversee the estimating department's      operations, including budget management, staffing decisions, wage reviews,      and performance evaluations.<\/li>\n <li>Collaborate with corporate and project      management to identify bidding opportunities, define strategies, and      select techniques for project bids.<\/li>\n <li>Prepare and manage the bid schedule,      tracking projects for estimate and proposal preparation from various      sources.<\/li>\n <li>Schedule and lead bid review meetings,      assessing project risks and establishing base wage rates for all estimates      and proposals.<\/li>\n <li>Develop Scope of Work packages for      construction subcontractors and vendors in coordination with the Project      Controls Manager and\/or Operations Support Manager.<\/li>\n <li>Maintain a comprehensive subcontractor      and vendor database, fostering positive relationships with these partners.<\/li>\n <li>Evaluate project requirements for DBE,      Small Business, MBE\/WBE participation, ensuring compliance with good faith      efforts and other regulations.<\/li>\n <li>Review bid forms for completeness and      accuracy, including the analysis of General and Special\/Supplemental      Conditions to appropriately assign costs.<\/li>\n <li>Coordinate scope reviews with the      project management team, ensuring project schedule requirements are fully      understood.<\/li>\n <li>Assign allowances and contingencies to      estimates and cost proposals, reviewing and adjusting final estimate      packages for accuracy before submission.<\/li>\n <li>Participate in presentations to      corporate management and clients, potentially being responsible for      closing sales.<\/li>\n <li>Conduct post-proposal activities,      securely archiving all original cost proposal documents and organizing      material for the project execution team.<\/li>\n <li>Establish and maintain a historical      cost database, tracking \"hit rates\" and other metrics to inform      future bidding strategies.<\/li>\n <li>Provide technical assistance in      negotiating contracts and change orders, and may assist in the preparation      of studies, materials, methods, and cost estimates as required.<\/li>\n<\/ul>\n<p><strong>Supervisory Responsibilities:<\/strong><\/p>\n<ul>\n <li>Form bid teams, assign work, and      monitor the progress of estimates and cost proposals.<\/li>\n <li>Assign attendees for pre-bid meetings      and mentor estimating staff, conducting performance reviews in conjunction      with the Operations Manager and\/or Chief Operations Officer.<\/li>\n <li>Develop and implement training programs      for junior estimators, enhancing their skills and knowledge.<\/li>\n<\/ul>\n<p><strong>Requirements:<\/strong><\/p>\n<ul>\n <li>Exceptional organizational,      supervisory, and decision-making skills, capable of efficiently handling      multiple priorities.<\/li>\n <li>Deep knowledge of construction and      design principles, including extensive estimating experience, construction      planning, and innovative problem-solving techniques.<\/li>\n <li>A thorough understanding of corporate      and industry practices, processes, standards, and their impact on      estimating strategies and techniques, as well as construction contracts.<\/li>\n<\/ul>\n<p><strong>Education and Experience:<\/strong><\/p>\n<ul>\n <li>A four-year engineering degree or an      equivalent combination of technical training and experience, with advanced      management or technical training preferred.<\/li>\n <li>Extensive experience (10 or more years)      in construction estimating and related functions, along with a thorough      knowledge of corporate objectives impacting estimating, strategies,      techniques, and construction contracts.<\/li>\n <li>Must possess excellent organizational,      supervisory, and decision-making\/problem-solving skills.<\/li>\n<\/ul>","%category%":"Sales","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/f6576f723d19-chief-estimator","%breezy_id%":"f6576f723d19","%breezy_friendly_id%":"f6576f723d19-chief-estimator","%breezy_created_date%":"2025-04-14T17:54:50.524Z","%breezy_updated_date%":"2025-07-29T15:50:53.063Z","%_wpgmp_location_city%":"Knoxville","%_wpgmp_location_state%":"TN","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Knoxville, TN, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"35.965266","%_wpgmp_metabox_longitude%":"-83.923304","%rank_math_internal_links_processed%":"1"}},"id":2373,"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-06-19T18:52:16.779Z","%_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":"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-06-19T18:23:22.579Z","%_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":2364,"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    Turner Staffing Group is seeking a skilled and motivated Pipe Layer to join a dynamic team with one of our&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/pipe-layer-2\/\" name=\"Pipe Layer\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Turner Staffing Group is seeking a skilled and motivated Pipe Layer to join a dynamic team with one of our&hellip;","address":"Charlotte, NC, USA","location":{"lat":"35.2215548","city":"Charlotte","state":"NC","country":"United States","lng":"-80.840116","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/pipe-layer-2\/","zoom":19,"extra_fields":{"post_excerpt":"Turner Staffing Group is seeking a skilled and motivated Pipe Layer to join a dynamic team with one of our&hellip;","post_content":"<p>Turner Staffing Group is seeking a skilled and motivated <strong>Pipe Layer<\/strong> to join a dynamic team with one of our clients in the Charlotte, NC area. Our client specializes in grading and utility work, and they are looking for an experienced Pipe Layer to support the installation of underground utility pipes.<\/p>\n<p>As a <strong>Pipe Layer<\/strong>, you will play a critical role in laying pipes for various underground utility systems. This is a contract-to-hire position, offering an opportunity to secure permanent employment with a reputable company known for its quality work in the construction and utility industry.<\/p>\n<p><strong>Key Responsibilities:<\/strong><\/p>\n<ul>\n<li>\n<p>Lay and install pipes for underground utilities, including water, sewer, and stormwater systems.<\/p>\n<\/li>\n<li>\n<p>Ensure proper alignment, level, and slope of pipes during installation.<\/p>\n<\/li>\n<li>\n<p>Prepare trenches and ensure they are properly supported before installation.<\/p>\n<\/li>\n<li>\n<p>Operate and maintain equipment used for trenching and pipe laying.<\/p>\n<\/li>\n<li>\n<p>Collaborate with supervisors and other crew members to complete projects on time and within safety standards.<\/p>\n<\/li>\n<li>\n<p>Assist with preparing and verifying project sites, ensuring all safety regulations are followed.<\/p>\n<\/li>\n<li>\n<p>Perform other related duties as assigned by supervisors.<\/p>\n<\/li>\n<\/ul>\n<p><strong>Qualifications:<\/strong><\/p>\n<ul>\n<li>\n<p>Previous experience in pipe laying or utility installation is preferred.<\/p>\n<\/li>\n<li>\n<p>Familiarity with underground utility systems, tools, and techniques.<\/p>\n<\/li>\n<li>\n<p>Ability to read blueprints and construction plans.<\/p>\n<\/li>\n<li>\n<p>Strong attention to detail and ability to work efficiently in a team environment.<\/p>\n<\/li>\n<li>\n<p>Reliable, punctual, and able to adhere to safety protocols.<\/p>\n<\/li>\n<li>\n<p>Ability to lift and carry heavy materials and work in various weather conditions.<\/p>\n<\/li>\n<\/ul>\n<p><strong>Why Join Us:<\/strong><\/p>\n<ul>\n<li>\n<p>Contract-to-hire opportunity with the potential for long-term employment.<\/p>\n<\/li>\n<li>\n<p>Competitive pay and benefits.<\/p>\n<\/li>\n<li>\n<p>Work with a respected company in the grading and utility industry.<\/p>\n<\/li>\n<li>\n<p>Safe, supportive work environment with opportunities for career growth.<\/p><\/li><\/ul>","post_title":"Pipe Layer","post_link":"https:\/\/turnerstaffing.com\/position\/pipe-layer-2\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"","%location_country%":"United States","%location_city%":"Charlotte","%location_state_id%":"NC","%location_state_name%":"North Carolina","%location_city_state%":"Charlotte, NC","%education%":"","%department%":"","%description%":"<p>Turner Staffing Group is seeking a skilled and motivated <strong>Pipe Layer<\/strong> to join a dynamic team with one of our clients in the Charlotte, NC area. Our client specializes in grading and utility work, and they are looking for an experienced Pipe Layer to support the installation of underground utility pipes.<\/p>\n<p>As a <strong>Pipe Layer<\/strong>, you will play a critical role in laying pipes for various underground utility systems. This is a contract-to-hire position, offering an opportunity to secure permanent employment with a reputable company known for its quality work in the construction and utility industry.<\/p>\n<p><strong>Key Responsibilities:<\/strong><\/p>\n<ul>\n<li>\n<p>Lay and install pipes for underground utilities, including water, sewer, and stormwater systems.<\/p>\n<\/li>\n<li>\n<p>Ensure proper alignment, level, and slope of pipes during installation.<\/p>\n<\/li>\n<li>\n<p>Prepare trenches and ensure they are properly supported before installation.<\/p>\n<\/li>\n<li>\n<p>Operate and maintain equipment used for trenching and pipe laying.<\/p>\n<\/li>\n<li>\n<p>Collaborate with supervisors and other crew members to complete projects on time and within safety standards.<\/p>\n<\/li>\n<li>\n<p>Assist with preparing and verifying project sites, ensuring all safety regulations are followed.<\/p>\n<\/li>\n<li>\n<p>Perform other related duties as assigned by supervisors.<\/p>\n<\/li>\n<\/ul>\n<p><strong>Qualifications:<\/strong><\/p>\n<ul>\n<li>\n<p>Previous experience in pipe laying or utility installation is preferred.<\/p>\n<\/li>\n<li>\n<p>Familiarity with underground utility systems, tools, and techniques.<\/p>\n<\/li>\n<li>\n<p>Ability to read blueprints and construction plans.<\/p>\n<\/li>\n<li>\n<p>Strong attention to detail and ability to work efficiently in a team environment.<\/p>\n<\/li>\n<li>\n<p>Reliable, punctual, and able to adhere to safety protocols.<\/p>\n<\/li>\n<li>\n<p>Ability to lift and carry heavy materials and work in various weather conditions.<\/p>\n<\/li>\n<\/ul>\n<p><strong>Why Join Us:<\/strong><\/p>\n<ul>\n<li>\n<p>Contract-to-hire opportunity with the potential for long-term employment.<\/p>\n<\/li>\n<li>\n<p>Competitive pay and benefits.<\/p>\n<\/li>\n<li>\n<p>Work with a respected company in the grading and utility industry.<\/p>\n<\/li>\n<li>\n<p>Safe, supportive work environment with opportunities for career growth.<\/p><\/li><\/ul>","%category%":"","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/c0668de6740f-pipe-layer","%breezy_id%":"c0668de6740f","%breezy_friendly_id%":"c0668de6740f-pipe-layer","%breezy_created_date%":"2025-04-08T14:40:27.015Z","%breezy_updated_date%":"2025-07-29T15:51:22.835Z","%_wpgmp_location_city%":"Charlotte","%_wpgmp_location_state%":"NC","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Charlotte, NC, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"35.2215548","%_wpgmp_metabox_longitude%":"-80.840116","%rank_math_internal_links_processed%":"1"}},"id":2355,"infowindow_disable":false},{"source":"post","title":"Civil Engineer","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Civil Engineer\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Job Title: Civil EngineerLocation: Kershaw, SCJob Type: Full-time Job Overview:Turner Staffing Group is partnered with a mining company seeking a&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/civil-engineer\/\" name=\"Civil Engineer\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Job Title: Civil EngineerLocation: Kershaw, SCJob Type: Full-time Job Overview:Turner Staffing Group is partnered with a mining company seeking a&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\/civil-engineer\/","zoom":19,"extra_fields":{"post_excerpt":"Job Title: Civil EngineerLocation: Kershaw, SCJob Type: Full-time Job Overview:Turner Staffing Group is partnered with a mining company seeking a&hellip;","post_content":"<p><strong>Job Title: Civil Engineer<\/strong><br><strong>Location:<\/strong> Kershaw, SC<br><strong>Job Type:<\/strong> Full-time<\/p>\n<p><strong>Job Overview:<\/strong><br>Turner Staffing Group is partnered with a mining company seeking a highly motivated <strong>Civil Engineer<\/strong> to coordinate and monitor construction activities at their site. The Civil Engineer will be responsible for overseeing projects, ensuring compliance with quality and safety standards, and maintaining accurate documentation of project progress.<\/p>\n<p><strong>Key Responsibilities:<\/strong><\/p>\n<ul><li>Coordinate functions during the development, approval, and execution phases of capital works.<\/li><li>Review construction drawings and specifications.<\/li><li>Ensure appropriate QA\/QC documentation (inspection test plans) is in place before work begins.<\/li><li>Support project execution to meet technical, quality, budgetary, and scheduling requirements.<\/li><li>Maintain records of construction, including incidents, progress, delays, and milestone achievements.<\/li><li>Assist with developing a master schedule with interrelationships between projects.<\/li><li>Communicate effectively with team members and other personnel.<\/li><li>Manage utilization database, track invoices, and monitor project costs.<\/li><li>Review and verify contractor baseline schedules and monthly updates for accuracy and compliance.<\/li><li>Ensure AFEs, Professional Service Agreements, Contracts, and Purchase Orders are in place before work begins.<\/li><li>Conduct and document field leadership safety interactions.<\/li><li>Identify and manage hazards within construction work areas.<\/li><li>Ensure construction activities align with project documents and specifications.<\/li><li>Work closely with Project Engineers in terms of project development.<\/li><\/ul>\n<p><strong>Qualifications:<\/strong><\/p>\n<ul><li>Bachelor\u2019s degree in Civil Engineering or related field.<\/li><li>Minimum of <strong>5 years of experience<\/strong> in a mining environment preferred.<\/li><li>Previous experience in civil construction preferred.<\/li><li>Experience in <strong>Tails Storage Facility (TSF) Construction<\/strong> preferred.<\/li><li>Knowledge of water retention facilities is beneficial.<\/li><li>Proficiency in CAD or Vulcan software preferred.<\/li><li>Experience with <strong>Microsoft Projects<\/strong> for scheduling preferred.<\/li><li>Strong computer literacy and familiarity with industry-standard software.<\/li><li>Experience in <strong>DOT highway construction<\/strong> is beneficial.<\/li><li>Excellent organizational, reporting, and cost-writing skills.<\/li><li>Positive attitude, strong work ethic, flexibility, and willingness to complete projects.<\/li><\/ul>\n<p><strong>Physical Requirements:<\/strong><\/p>\n<ul><li>Ability to stand, sit, demonstrate manual dexterity, climb stairs, talk, hear, and see.<\/li><li>Must be able to work <strong>12-hour shifts<\/strong> as needed.<\/li><li>Occasionally lift up to <strong>50 pounds<\/strong>.<\/li><li>Work in a <strong>surface mine plant setting<\/strong> with exposure to temperature and humidity extremes.<\/li><li>Use of personal protective equipment (PPE) including hard hat, hearing protection, safety glasses, safety footwear, and, as needed, respirator, steel-toe boots, gloves, and other protective gear.<\/li><\/ul>\n<p><strong>Equal Opportunity Employer:<\/strong><br>Turner Staffing Group and our partner company are committed to providing equal employment opportunities. All qualified candidates will be considered regardless of background.<\/p>\n<p><strong>How to Apply:<\/strong><br>If you meet the qualifications and are looking for a challenging yet rewarding opportunity, apply today!<\/p>\n<p><\/p>","post_title":"Civil Engineer","post_link":"https:\/\/turnerstaffing.com\/position\/civil-engineer\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Mid Level","%location_country%":"United States","%location_city%":"Kershaw","%location_state_id%":"SC","%location_state_name%":"South Carolina","%location_city_state%":"Kershaw, SC","%education%":"Bachelor's Degree","%department%":"Operations","%description%":"<p><strong>Job Title: Civil Engineer<\/strong><br><strong>Location:<\/strong> Kershaw, SC<br><strong>Job Type:<\/strong> Full-time<\/p>\n<p><strong>Job Overview:<\/strong><br>Turner Staffing Group is partnered with a mining company seeking a highly motivated <strong>Civil Engineer<\/strong> to coordinate and monitor construction activities at their site. The Civil Engineer will be responsible for overseeing projects, ensuring compliance with quality and safety standards, and maintaining accurate documentation of project progress.<\/p>\n<p><strong>Key Responsibilities:<\/strong><\/p>\n<ul><li>Coordinate functions during the development, approval, and execution phases of capital works.<\/li><li>Review construction drawings and specifications.<\/li><li>Ensure appropriate QA\/QC documentation (inspection test plans) is in place before work begins.<\/li><li>Support project execution to meet technical, quality, budgetary, and scheduling requirements.<\/li><li>Maintain records of construction, including incidents, progress, delays, and milestone achievements.<\/li><li>Assist with developing a master schedule with interrelationships between projects.<\/li><li>Communicate effectively with team members and other personnel.<\/li><li>Manage utilization database, track invoices, and monitor project costs.<\/li><li>Review and verify contractor baseline schedules and monthly updates for accuracy and compliance.<\/li><li>Ensure AFEs, Professional Service Agreements, Contracts, and Purchase Orders are in place before work begins.<\/li><li>Conduct and document field leadership safety interactions.<\/li><li>Identify and manage hazards within construction work areas.<\/li><li>Ensure construction activities align with project documents and specifications.<\/li><li>Work closely with Project Engineers in terms of project development.<\/li><\/ul>\n<p><strong>Qualifications:<\/strong><\/p>\n<ul><li>Bachelor\u2019s degree in Civil Engineering or related field.<\/li><li>Minimum of <strong>5 years of experience<\/strong> in a mining environment preferred.<\/li><li>Previous experience in civil construction preferred.<\/li><li>Experience in <strong>Tails Storage Facility (TSF) Construction<\/strong> preferred.<\/li><li>Knowledge of water retention facilities is beneficial.<\/li><li>Proficiency in CAD or Vulcan software preferred.<\/li><li>Experience with <strong>Microsoft Projects<\/strong> for scheduling preferred.<\/li><li>Strong computer literacy and familiarity with industry-standard software.<\/li><li>Experience in <strong>DOT highway construction<\/strong> is beneficial.<\/li><li>Excellent organizational, reporting, and cost-writing skills.<\/li><li>Positive attitude, strong work ethic, flexibility, and willingness to complete projects.<\/li><\/ul>\n<p><strong>Physical Requirements:<\/strong><\/p>\n<ul><li>Ability to stand, sit, demonstrate manual dexterity, climb stairs, talk, hear, and see.<\/li><li>Must be able to work <strong>12-hour shifts<\/strong> as needed.<\/li><li>Occasionally lift up to <strong>50 pounds<\/strong>.<\/li><li>Work in a <strong>surface mine plant setting<\/strong> with exposure to temperature and humidity extremes.<\/li><li>Use of personal protective equipment (PPE) including hard hat, hearing protection, safety glasses, safety footwear, and, as needed, respirator, steel-toe boots, gloves, and other protective gear.<\/li><\/ul>\n<p><strong>Equal Opportunity Employer:<\/strong><br>Turner Staffing Group and our partner company are committed to providing equal employment opportunities. All qualified candidates will be considered regardless of background.<\/p>\n<p><strong>How to Apply:<\/strong><br>If you meet the qualifications and are looking for a challenging yet rewarding opportunity, apply today!<\/p>\n<p><\/p>","%category%":"Operations","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/0995afc35c61-civil-engineer","%breezy_id%":"0995afc35c61","%breezy_friendly_id%":"0995afc35c61-civil-engineer","%breezy_created_date%":"2025-04-04T14:06:36.745Z","%breezy_updated_date%":"2025-07-29T15:50:55.028Z","%_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":2340,"infowindow_disable":false},{"source":"post","title":"Process Maintenance Superintendent","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Process Maintenance Superintendent\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Job Description &nbsp;Under the direction of the Ore Processing Manager, the Process Maintenance Superintendent directs all activities for their respective&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/process-maintenance-superintendent\/\" name=\"Process Maintenance Superintendent\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Job Description &nbsp;Under the direction of the Ore Processing Manager, the Process Maintenance Superintendent directs all activities for their respective&hellip;","address":"Round Mountain, NV, USA","location":{"lat":"38.7110428","city":"Round Mountain","state":"NV","country":"United States","lng":"-117.0675843","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/process-maintenance-superintendent\/","zoom":19,"extra_fields":{"post_excerpt":"Job Description &nbsp;Under the direction of the Ore Processing Manager, the Process Maintenance Superintendent directs all activities for their respective&hellip;","post_content":"<h2>Job Description<\/h2>\n<p>&nbsp;Under the direction of the Ore Processing Manager, the Process Maintenance Superintendent directs all activities for their respective maintenance department to meet production goals in a safe and efficient manner. &nbsp;<\/p>\n<h2>Job Responsibilities<\/h2>\n<p>Safety and Compliance:<br>\u2022&nbsp;&nbsp; &nbsp;Set and enforce a culture of safety excellence, ensuring strict adherence to health, safety, and environmental regulations.<br>\u2022&nbsp;&nbsp; &nbsp;Conduct regular safety meetings and training sessions for the team.<br>\u2022&nbsp;&nbsp; &nbsp;Lead safety audits, incident investigations, and root cause analyses to prevent future occurrences.<br>\u2022&nbsp;&nbsp; &nbsp;Ensure all maintenance personnel are trained in the latest safety protocols and emergency response procedures.<br>\u2022&nbsp;&nbsp; &nbsp;Develop and oversee safety programs, hazard assessments, and risk mitigation strategies for maintenance activities.<\/p>\n<p>Strategic Team Leadership and Development:<br>\u2022&nbsp;&nbsp; &nbsp;Actively engage in workforce planning, recruiting, and succession planning to develop a skilled and adaptable maintenance team.<br>\u2022&nbsp;&nbsp; &nbsp;Supervise, mentor, and develop the Process and Electrical Maintenance team.&nbsp;&nbsp; &nbsp;<br>\u2022&nbsp;&nbsp; &nbsp;Organize work plans, prioritize, and administer processes and procedures to ensure efficient use of time and resources.<br>\u2022&nbsp;&nbsp; &nbsp;Promote a high-performance culture by setting expectations, conducting performance reviews, and providing feedback and coaching.<br>\u2022&nbsp;&nbsp; &nbsp;Foster a culture of accountability, performance excellence, and continuous learning.<br>&nbsp;<\/p>\n<h2>Education and Experience<\/h2>\n<p>1.&nbsp;&nbsp; &nbsp;Bachelor\u2019s degree in mechanical engineering, electrical engineering, or a related field preferred.&nbsp;<br>2.&nbsp;&nbsp; &nbsp;Strong understanding of CIC, VCIC, Kilns, Scrubbers, Pressure Strip, pumps, leaching &amp; other systems related to gold recovery.<br>3.&nbsp;&nbsp; &nbsp;Minimum 10-15 years of progressive maintenance experience in mining, heavy industry, or mineral processing, with at least 5 years in a senior leadership role.&nbsp;<br>4.&nbsp;&nbsp; &nbsp;Certified Maintenance &amp; Reliability Professional (CMRP) or equivalent is highly desirable.<br>5.&nbsp;&nbsp; &nbsp;Proven track record in developing and implementing reliability-centered maintenance programs\/<br>6.&nbsp;&nbsp; &nbsp;Proficient with CMMS software (e.g., JDE, SAP, Pronto) and advanced maintenance analytics, JDE preferred.<br>7.&nbsp;&nbsp; &nbsp;Proficient in Microsoft office required.<br>8.&nbsp;&nbsp; &nbsp;Strong leadership, problem-solving, and decision-making skills with the ability to engage and influence at all organizational levels.&nbsp;<br>9.&nbsp;&nbsp; &nbsp;Must be 18 years old and presently authorized to work in the United States on a full time basis.&nbsp;<br>10.&nbsp;&nbsp; &nbsp;Requires valid driver\u2019s license.<br>11.&nbsp;&nbsp; &nbsp;The ability to communicate with all levels of personnel<br>12.&nbsp;&nbsp; &nbsp;Strong leadership\/team building skills<br>&nbsp;<\/p>\n<h2>Operational Management<\/h2>\n<p><br>\u2022&nbsp;&nbsp; &nbsp;Develop and implement a long-term maintenance strategy focused on maximizing plant availability, minimizing unplanned downtime, and optimizing asset life cycles.<br>\u2022&nbsp;&nbsp; &nbsp;Oversee all aspects of daily operation for fixed plant maintenance and electrical systems, including crushers, mills, conveyors, pumps, leaching circuits, and other critical process equipment.<br>\u2022&nbsp;&nbsp; &nbsp;Oversee maintenance planning and execution, ensuring all scheduled, corrective, and emergency repairs are completed efficiently.<br>\u2022&nbsp;&nbsp; &nbsp;Lead major shutdowns, turnarounds, and capital improvement projects, ensuring safe and timely execution.<br>\u2022&nbsp;&nbsp; &nbsp;Ensure the timely and efficient completion of preventive and corrective maintenance to minimize downtime and maximize equipment availability.<br>\u2022&nbsp;&nbsp; &nbsp;Align maintenance strategies with business objectives, ensuring cost-effective asset management and risk mitigation<br>\u2022&nbsp;&nbsp; &nbsp;Establish and monitor key performance indicators (KPIs) such as equipment availability, mean time between failures, and repair turnaround time to ensure accountability for maintenance performance across all levels.<br>\u2022&nbsp;&nbsp; &nbsp;Lead continuous improvement initiatives, integrating new technologies and industry best practices to enhance plant performance.&nbsp;<br>\u2022&nbsp;&nbsp; &nbsp;Diagnose and troubleshoot equipment failures, providing technical guidance to the maintenance team.<br>\u2022&nbsp;&nbsp; &nbsp;Champion reliability-centered maintenance (RCM) and condition monitoring programs to proactively identify and address potential failures.&nbsp;<br>\u2022&nbsp;&nbsp; &nbsp;Ensure that the team is properly trained in the latest techniques, tools, and safety standards.<br>\u2022&nbsp;&nbsp; &nbsp;Collaborate with the Mine Operations, Processing, and Engineering teams to align maintenance activities with overall production schedules.<br>\u2022&nbsp;&nbsp; &nbsp;Develop, manage, and optimize the fixed plant maintenance budget, balancing cost control with operational reliability.&nbsp;<br>\u2022&nbsp;&nbsp; &nbsp;Collaborate with Procurement and Inventory teams to establish a strategic spare parts management system that reduces downtime and minimizes carrying costs.&nbsp;<br>\u2022&nbsp;&nbsp; &nbsp;Engage with senior leadership to develop capital investment strategies for plant infrastructure and equipment upgrades.<br>\u2022&nbsp;&nbsp; &nbsp;Oversee contractor management, ensuring compliance with scope, quality, and safety requirements.<br>\u2022&nbsp;&nbsp; &nbsp;Drive the adoption of digital solutions and predictive maintenance technologies to enhance asset performance and data-driven decision-making.<br>\u2022&nbsp;&nbsp; &nbsp;Implement CMMS enhancements and optimize maintenance workflows to improve efficiency and reporting accuracy.<br>\u2022&nbsp;&nbsp; &nbsp;Research and recommend industry advancements, such as automation, energy-efficient technologies, and AI-driven predictive analytics, to improve plant performance.<\/p>","post_title":"Process Maintenance Superintendent","post_link":"https:\/\/turnerstaffing.com\/position\/process-maintenance-superintendent\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Senior","%location_country%":"United States","%location_city%":"Round Mountain","%location_state_id%":"NV","%location_state_name%":"Nevada","%location_city_state%":"Round Mountain, NV","%education%":"Unspecified","%department%":"","%description%":"<h2>Job Description<\/h2>\n<p>&nbsp;Under the direction of the Ore Processing Manager, the Process Maintenance Superintendent directs all activities for their respective maintenance department to meet production goals in a safe and efficient manner. &nbsp;<\/p>\n<h2>Job Responsibilities<\/h2>\n<p>Safety and Compliance:<br>\u2022&nbsp;&nbsp; &nbsp;Set and enforce a culture of safety excellence, ensuring strict adherence to health, safety, and environmental regulations.<br>\u2022&nbsp;&nbsp; &nbsp;Conduct regular safety meetings and training sessions for the team.<br>\u2022&nbsp;&nbsp; &nbsp;Lead safety audits, incident investigations, and root cause analyses to prevent future occurrences.<br>\u2022&nbsp;&nbsp; &nbsp;Ensure all maintenance personnel are trained in the latest safety protocols and emergency response procedures.<br>\u2022&nbsp;&nbsp; &nbsp;Develop and oversee safety programs, hazard assessments, and risk mitigation strategies for maintenance activities.<\/p>\n<p>Strategic Team Leadership and Development:<br>\u2022&nbsp;&nbsp; &nbsp;Actively engage in workforce planning, recruiting, and succession planning to develop a skilled and adaptable maintenance team.<br>\u2022&nbsp;&nbsp; &nbsp;Supervise, mentor, and develop the Process and Electrical Maintenance team.&nbsp;&nbsp; &nbsp;<br>\u2022&nbsp;&nbsp; &nbsp;Organize work plans, prioritize, and administer processes and procedures to ensure efficient use of time and resources.<br>\u2022&nbsp;&nbsp; &nbsp;Promote a high-performance culture by setting expectations, conducting performance reviews, and providing feedback and coaching.<br>\u2022&nbsp;&nbsp; &nbsp;Foster a culture of accountability, performance excellence, and continuous learning.<br>&nbsp;<\/p>\n<h2>Education and Experience<\/h2>\n<p>1.&nbsp;&nbsp; &nbsp;Bachelor\u2019s degree in mechanical engineering, electrical engineering, or a related field preferred.&nbsp;<br>2.&nbsp;&nbsp; &nbsp;Strong understanding of CIC, VCIC, Kilns, Scrubbers, Pressure Strip, pumps, leaching &amp; other systems related to gold recovery.<br>3.&nbsp;&nbsp; &nbsp;Minimum 10-15 years of progressive maintenance experience in mining, heavy industry, or mineral processing, with at least 5 years in a senior leadership role.&nbsp;<br>4.&nbsp;&nbsp; &nbsp;Certified Maintenance &amp; Reliability Professional (CMRP) or equivalent is highly desirable.<br>5.&nbsp;&nbsp; &nbsp;Proven track record in developing and implementing reliability-centered maintenance programs\/<br>6.&nbsp;&nbsp; &nbsp;Proficient with CMMS software (e.g., JDE, SAP, Pronto) and advanced maintenance analytics, JDE preferred.<br>7.&nbsp;&nbsp; &nbsp;Proficient in Microsoft office required.<br>8.&nbsp;&nbsp; &nbsp;Strong leadership, problem-solving, and decision-making skills with the ability to engage and influence at all organizational levels.&nbsp;<br>9.&nbsp;&nbsp; &nbsp;Must be 18 years old and presently authorized to work in the United States on a full time basis.&nbsp;<br>10.&nbsp;&nbsp; &nbsp;Requires valid driver\u2019s license.<br>11.&nbsp;&nbsp; &nbsp;The ability to communicate with all levels of personnel<br>12.&nbsp;&nbsp; &nbsp;Strong leadership\/team building skills<br>&nbsp;<\/p>\n<h2>Operational Management<\/h2>\n<p><br>\u2022&nbsp;&nbsp; &nbsp;Develop and implement a long-term maintenance strategy focused on maximizing plant availability, minimizing unplanned downtime, and optimizing asset life cycles.<br>\u2022&nbsp;&nbsp; &nbsp;Oversee all aspects of daily operation for fixed plant maintenance and electrical systems, including crushers, mills, conveyors, pumps, leaching circuits, and other critical process equipment.<br>\u2022&nbsp;&nbsp; &nbsp;Oversee maintenance planning and execution, ensuring all scheduled, corrective, and emergency repairs are completed efficiently.<br>\u2022&nbsp;&nbsp; &nbsp;Lead major shutdowns, turnarounds, and capital improvement projects, ensuring safe and timely execution.<br>\u2022&nbsp;&nbsp; &nbsp;Ensure the timely and efficient completion of preventive and corrective maintenance to minimize downtime and maximize equipment availability.<br>\u2022&nbsp;&nbsp; &nbsp;Align maintenance strategies with business objectives, ensuring cost-effective asset management and risk mitigation<br>\u2022&nbsp;&nbsp; &nbsp;Establish and monitor key performance indicators (KPIs) such as equipment availability, mean time between failures, and repair turnaround time to ensure accountability for maintenance performance across all levels.<br>\u2022&nbsp;&nbsp; &nbsp;Lead continuous improvement initiatives, integrating new technologies and industry best practices to enhance plant performance.&nbsp;<br>\u2022&nbsp;&nbsp; &nbsp;Diagnose and troubleshoot equipment failures, providing technical guidance to the maintenance team.<br>\u2022&nbsp;&nbsp; &nbsp;Champion reliability-centered maintenance (RCM) and condition monitoring programs to proactively identify and address potential failures.&nbsp;<br>\u2022&nbsp;&nbsp; &nbsp;Ensure that the team is properly trained in the latest techniques, tools, and safety standards.<br>\u2022&nbsp;&nbsp; &nbsp;Collaborate with the Mine Operations, Processing, and Engineering teams to align maintenance activities with overall production schedules.<br>\u2022&nbsp;&nbsp; &nbsp;Develop, manage, and optimize the fixed plant maintenance budget, balancing cost control with operational reliability.&nbsp;<br>\u2022&nbsp;&nbsp; &nbsp;Collaborate with Procurement and Inventory teams to establish a strategic spare parts management system that reduces downtime and minimizes carrying costs.&nbsp;<br>\u2022&nbsp;&nbsp; &nbsp;Engage with senior leadership to develop capital investment strategies for plant infrastructure and equipment upgrades.<br>\u2022&nbsp;&nbsp; &nbsp;Oversee contractor management, ensuring compliance with scope, quality, and safety requirements.<br>\u2022&nbsp;&nbsp; &nbsp;Drive the adoption of digital solutions and predictive maintenance technologies to enhance asset performance and data-driven decision-making.<br>\u2022&nbsp;&nbsp; &nbsp;Implement CMMS enhancements and optimize maintenance workflows to improve efficiency and reporting accuracy.<br>\u2022&nbsp;&nbsp; &nbsp;Research and recommend industry advancements, such as automation, energy-efficient technologies, and AI-driven predictive analytics, to improve plant performance.<\/p>","%category%":"Management","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/cc9303fade83-process-maintenance-superintendent","%breezy_id%":"cc9303fade83","%breezy_friendly_id%":"cc9303fade83-process-maintenance-superintendent","%breezy_created_date%":"2025-04-02T19:01:14.358Z","%breezy_updated_date%":"2025-07-29T15:51:25.098Z","%_wpgmp_location_city%":"Round Mountain","%_wpgmp_location_state%":"NV","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Round Mountain, NV, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"38.7110428","%_wpgmp_metabox_longitude%":"-117.0675843","%rank_math_internal_links_processed%":"1"}},"id":2320,"infowindow_disable":false},{"source":"post","title":"Heavy Equipment Operator","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Heavy Equipment Operator\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Turner Mining Group \u2013 Heavy Equipment Operator 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\/heavy-equipment-operator-3\/\" name=\"Heavy Equipment Operator\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Turner Mining Group \u2013 Heavy Equipment Operator We are looking for a dynamic and talented mining Heavy Equipment Operators for&hellip;","address":"Pacific, MO, USA","location":{"lat":"38.4819976","city":"Pacific","state":"MO","country":"United States","lng":"-90.7415194","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/heavy-equipment-operator-3\/","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><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":"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%":"Pacific","%location_state_id%":"MO","%location_state_name%":"Missouri","%location_city_state%":"Pacific, MO","%education%":"Unspecified","%department%":"Operations","%description%":"<p><strong><u>Turner Mining Group \u2013 Heavy Equipment Operator<\/u><\/strong><\/p>\n<p><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\/eac6388e8c5b-heavy-equipment-operator","%breezy_id%":"eac6388e8c5b","%breezy_friendly_id%":"eac6388e8c5b-heavy-equipment-operator","%breezy_created_date%":"2025-04-02T14:10:27.256Z","%breezy_updated_date%":"2025-07-14T13:09:10.458Z","%_wpgmp_location_city%":"Pacific","%_wpgmp_location_state%":"MO","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Pacific, MO, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"38.4819976","%_wpgmp_metabox_longitude%":"-90.7415194","%rank_math_internal_links_processed%":"1"}},"id":2317,"infowindow_disable":false},{"source":"post","title":"Site Coordinator","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Site Coordinator\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Job Title: On-Site HR CoordinatorLocation:&nbsp;Kershaw, SCCompany: Turner Staffing Group Position Overview:Turner Staffing Group is seeking a dedicated and proactive On-Site&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/hr-recruiting-coordinator\/\" name=\"Site Coordinator\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Job Title: On-Site HR CoordinatorLocation:&nbsp;Kershaw, SCCompany: Turner Staffing Group Position Overview:Turner Staffing Group is seeking a dedicated and proactive On-Site&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\/hr-recruiting-coordinator\/","zoom":19,"extra_fields":{"post_excerpt":"Job Title: On-Site HR CoordinatorLocation:&nbsp;Kershaw, SCCompany: Turner Staffing Group Position Overview:Turner Staffing Group is seeking a dedicated and proactive On-Site&hellip;","post_content":"<p><strong>Job Title:<\/strong> On-Site HR Coordinator<br><strong>Location:<\/strong>&nbsp;Kershaw, SC<br><strong>Company:<\/strong> Turner Staffing Group<\/p>\n<p><strong>Position Overview:<\/strong><br>Turner Staffing Group is seeking a dedicated and proactive On-Site HR Coordinator to support our operations at a client\u2019s mine site in South Carolina. This individual will serve as the primary point of contact for all Turner Staffing Group employees on-site, handling HR-related inquiries, compliance matters, and administrative tasks. The On-Site HR Coordinator will play a critical role in ensuring smooth workforce operations, maintaining compliance with MSHA regulations, and expanding Turner Staffing Group\u2019s presence across various departments within the mine.<\/p>\n<p><strong>Key Responsibilities:<\/strong><\/p>\n<ul><li>Serve as the on-site representative of Turner Staffing Group, acting as the primary HR contact for all contractors and employees.<\/li><li>Address employee concerns, questions, and HR-related issues in a timely and professional manner.<\/li><li>Assist in recruiting efforts by promoting Turner Staffing Group opportunities within the mine site and identifying potential candidates for open positions.<\/li><li>Ensure all Turner Staffing Group employees comply with MSHA (Mine Safety and Health Administration) regulations and company safety policies.<\/li><li>Conduct and coordinate safety training, onboarding, and orientation for new hires in collaboration with site management.<\/li><li>Maintain accurate employee records, including attendance, certifications, and compliance documentation.<\/li><li>Work closely with mine site management to ensure staffing needs are met and provide HR support as needed.<\/li><li>Manage and oversee administrative tasks such as payroll coordination, employee scheduling, and timesheet verification.<\/li><li>Foster a positive and professional working relationship between Turner Staffing Group employees and the client\u2019s leadership team.<\/li><li>Provide guidance on employee performance, conflict resolution, and disciplinary actions in alignment with company policies.<\/li><li>Assist in workforce development initiatives, including training programs and employee engagement efforts.<\/li><\/ul>\n<p><strong>Qualifications:<\/strong><\/p>\n<ul><li>Bachelor\u2019s degree in Human Resources, Business Administration, or a related field preferred, or equivalent HR experience.<\/li><li>Minimum of 2 years of experience in an HR-related role, preferably in a staffing, industrial, or mining environment.<\/li><li>Strong knowledge of HR policies, employment laws, and MSHA compliance requirements.<\/li><li>Excellent interpersonal and communication skills with the ability to build relationships at all levels.<\/li><li>Proficiency in Microsoft Office Suite (Word, Excel, Outlook) and HR software.<\/li><li>Ability to work independently and manage multiple tasks in a fast-paced environment.<\/li><li>Strong problem-solving skills and attention to detail.<\/li><li>Prior experience in a mining or industrial setting is a plus.<\/li><li>Ability to travel to the mine site daily and work flexible hours as needed.<\/li><\/ul>\n<p><strong>Benefits:<\/strong><\/p>\n<ul><li>Competitive salary based on experience.<\/li><li>Comprehensive benefits package including health, dental, and vision insurance.<\/li><li>401(k) with company match.<\/li><li>Paid time off and holiday pay.<\/li><li>Opportunities for career growth within Turner Staffing Group.<\/li><\/ul>","post_title":"Site Coordinator","post_link":"https:\/\/turnerstaffing.com\/position\/hr-recruiting-coordinator\/","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%":"","%description%":"<p><strong>Job Title:<\/strong> On-Site HR Coordinator<br><strong>Location:<\/strong>&nbsp;Kershaw, SC<br><strong>Company:<\/strong> Turner Staffing Group<\/p>\n<p><strong>Position Overview:<\/strong><br>Turner Staffing Group is seeking a dedicated and proactive On-Site HR Coordinator to support our operations at a client\u2019s mine site in South Carolina. This individual will serve as the primary point of contact for all Turner Staffing Group employees on-site, handling HR-related inquiries, compliance matters, and administrative tasks. The On-Site HR Coordinator will play a critical role in ensuring smooth workforce operations, maintaining compliance with MSHA regulations, and expanding Turner Staffing Group\u2019s presence across various departments within the mine.<\/p>\n<p><strong>Key Responsibilities:<\/strong><\/p>\n<ul><li>Serve as the on-site representative of Turner Staffing Group, acting as the primary HR contact for all contractors and employees.<\/li><li>Address employee concerns, questions, and HR-related issues in a timely and professional manner.<\/li><li>Assist in recruiting efforts by promoting Turner Staffing Group opportunities within the mine site and identifying potential candidates for open positions.<\/li><li>Ensure all Turner Staffing Group employees comply with MSHA (Mine Safety and Health Administration) regulations and company safety policies.<\/li><li>Conduct and coordinate safety training, onboarding, and orientation for new hires in collaboration with site management.<\/li><li>Maintain accurate employee records, including attendance, certifications, and compliance documentation.<\/li><li>Work closely with mine site management to ensure staffing needs are met and provide HR support as needed.<\/li><li>Manage and oversee administrative tasks such as payroll coordination, employee scheduling, and timesheet verification.<\/li><li>Foster a positive and professional working relationship between Turner Staffing Group employees and the client\u2019s leadership team.<\/li><li>Provide guidance on employee performance, conflict resolution, and disciplinary actions in alignment with company policies.<\/li><li>Assist in workforce development initiatives, including training programs and employee engagement efforts.<\/li><\/ul>\n<p><strong>Qualifications:<\/strong><\/p>\n<ul><li>Bachelor\u2019s degree in Human Resources, Business Administration, or a related field preferred, or equivalent HR experience.<\/li><li>Minimum of 2 years of experience in an HR-related role, preferably in a staffing, industrial, or mining environment.<\/li><li>Strong knowledge of HR policies, employment laws, and MSHA compliance requirements.<\/li><li>Excellent interpersonal and communication skills with the ability to build relationships at all levels.<\/li><li>Proficiency in Microsoft Office Suite (Word, Excel, Outlook) and HR software.<\/li><li>Ability to work independently and manage multiple tasks in a fast-paced environment.<\/li><li>Strong problem-solving skills and attention to detail.<\/li><li>Prior experience in a mining or industrial setting is a plus.<\/li><li>Ability to travel to the mine site daily and work flexible hours as needed.<\/li><\/ul>\n<p><strong>Benefits:<\/strong><\/p>\n<ul><li>Competitive salary based on experience.<\/li><li>Comprehensive benefits package including health, dental, and vision insurance.<\/li><li>401(k) with company match.<\/li><li>Paid time off and holiday pay.<\/li><li>Opportunities for career growth within Turner Staffing Group.<\/li><\/ul>","%category%":"Operations","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/04102393dfc4-site-coordinator","%breezy_id%":"04102393dfc4","%breezy_friendly_id%":"04102393dfc4-site-coordinator","%breezy_created_date%":"2025-04-01T13:30:22.550Z","%breezy_updated_date%":"2025-08-01T19:39:46.228Z","%_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":2315,"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 We are looking for a dynamic and talented mining Haul Truck Drivers for&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/haul-truck-driver-off-road\/\" name=\"Haul Truck Driver\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Turner Mining Group \u2013 Haul Truck Driver We are looking for a dynamic and talented mining Haul Truck Drivers for&hellip;","address":"Pacific, MO, USA","location":{"lat":"38.4819976","city":"Pacific","state":"MO","country":"United States","lng":"-90.7415194","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/haul-truck-driver-off-road\/","zoom":19,"extra_fields":{"post_excerpt":"Turner Mining Group \u2013 Haul Truck Driver We are looking for a dynamic and talented mining Haul Truck Drivers for&hellip;","post_content":"<p><strong><u>Turner Mining Group \u2013 Haul Truck Driver<\/u><\/strong><br><\/p>\n\n<p>We are looking for a dynamic and talented mining Haul Truck Drivers for our fast-growing, forward thinking mining services company headquartered in Bloomington, Indiana with our Operations team headquartered in Salt Lake City, Utah.<\/p>\n<p>Turner Mining Group is seeking an energetic mining professionals who can leverage their mining knowledge to expand upon our fast-growing business, creating best practices for equipment operations to ensure profitable operations.<\/p>\n<p>If you would like to get involved and make a large contribution in mining or minerals processing, then you may enjoy a position as Haul Truck Driver. This position is great for anyone who would like to begin a career in mining, has experience in a related industry but would like to learn about mining, or has experience as a miner but would like to grow into further positions with Turner Mining Group.<\/p>\n<p><strong>You<\/strong><\/p>\n<p>You want to work for a services company that is rapidly changing the way the largest materials producers do business. You are motivated by solving problems and partnering with our clients and suppliers. You want to work with great people and enjoy being a part of a strong team. You are a knowledgeable Operator who is not afraid to jump into every detail. You want to be in a place where continuous learning and growth is the norm. You are adaptable and able to juggle multiple initiatives concurrently.<\/p>\n<p><strong>Responsibilities:<\/strong><\/p>\n<ul><li>Operate and drive heavy haul trucks to transport tons of materials over short distances in a surface environment.<\/li><li>Perform inspections of vehicle systems, equipment and accessories such as tires, lights, turn signals and brakes<\/li><li>Ensure cargo is properly loaded according to safety requirements<\/li><li>Follow all safety policies, procedures and legislation<\/li><li>Maintain paper or electronic logbook<\/li><li>Communicate with Dispatcher and other Haul Truck Drivers using communication devices such as a two-ways radio or onboard computers<\/li><li>May drive special purpose vehicles, including end dump trucks, center dump truck units and water trucks<\/li><\/ul>\n<p><strong>Requirements:<\/strong><\/p>\n<ul><li>Safety oriented, awareness of everyone and everything that is around you<\/li><li>Strong work ethic<\/li><li>Willingness to learn<\/li><li>Ability to be flexible and to adapt<\/li><li>Experience with heavy equipment<\/li><li>Preferred to have MSHA training<\/li><\/ul>\n<p><strong>Benefits:<\/strong><\/p>\n<p>Turner Mining Group offers a competitive salary, an excellent work culture, career advancement opportunities. Our team offers a benefits program which includes Medical, Dental, Vision, Life, and a 401k with company match.<\/p>\n<p>At Turner Mining Group, we encourage and celebrate an inclusive environment for all employees and are proud to be an equal opportunity workplace and affirmative action employer.<\/p>","post_title":"Haul Truck Driver","post_link":"https:\/\/turnerstaffing.com\/position\/haul-truck-driver-off-road\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"","%location_country%":"United States","%location_city%":"Pacific","%location_state_id%":"MO","%location_state_name%":"Missouri","%location_city_state%":"Pacific, MO","%education%":"Unspecified","%department%":"Operations","%description%":"<p><strong><u>Turner Mining Group \u2013 Haul Truck Driver<\/u><\/strong><br><\/p>\n\n<p>We are looking for a dynamic and talented mining Haul Truck Drivers for our fast-growing, forward thinking mining services company headquartered in Bloomington, Indiana with our Operations team headquartered in Salt Lake City, Utah.<\/p>\n<p>Turner Mining Group is seeking an energetic mining professionals who can leverage their mining knowledge to expand upon our fast-growing business, creating best practices for equipment operations to ensure profitable operations.<\/p>\n<p>If you would like to get involved and make a large contribution in mining or minerals processing, then you may enjoy a position as Haul Truck Driver. This position is great for anyone who would like to begin a career in mining, has experience in a related industry but would like to learn about mining, or has experience as a miner but would like to grow into further positions with Turner Mining Group.<\/p>\n<p><strong>You<\/strong><\/p>\n<p>You want to work for a services company that is rapidly changing the way the largest materials producers do business. You are motivated by solving problems and partnering with our clients and suppliers. You want to work with great people and enjoy being a part of a strong team. You are a knowledgeable Operator who is not afraid to jump into every detail. You want to be in a place where continuous learning and growth is the norm. You are adaptable and able to juggle multiple initiatives concurrently.<\/p>\n<p><strong>Responsibilities:<\/strong><\/p>\n<ul><li>Operate and drive heavy haul trucks to transport tons of materials over short distances in a surface environment.<\/li><li>Perform inspections of vehicle systems, equipment and accessories such as tires, lights, turn signals and brakes<\/li><li>Ensure cargo is properly loaded according to safety requirements<\/li><li>Follow all safety policies, procedures and legislation<\/li><li>Maintain paper or electronic logbook<\/li><li>Communicate with Dispatcher and other Haul Truck Drivers using communication devices such as a two-ways radio or onboard computers<\/li><li>May drive special purpose vehicles, including end dump trucks, center dump truck units and water trucks<\/li><\/ul>\n<p><strong>Requirements:<\/strong><\/p>\n<ul><li>Safety oriented, awareness of everyone and everything that is around you<\/li><li>Strong work ethic<\/li><li>Willingness to learn<\/li><li>Ability to be flexible and to adapt<\/li><li>Experience with heavy equipment<\/li><li>Preferred to have MSHA training<\/li><\/ul>\n<p><strong>Benefits:<\/strong><\/p>\n<p>Turner Mining Group offers a competitive salary, an excellent work culture, career advancement opportunities. Our team offers a benefits program which includes Medical, Dental, Vision, Life, and a 401k with company match.<\/p>\n<p>At Turner Mining Group, we encourage and celebrate an inclusive environment for all employees and are proud to be an equal opportunity workplace and affirmative action employer.<\/p>","%category%":"Operations","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/d9e1112d4798-haul-truck-driver","%breezy_id%":"d9e1112d4798","%breezy_friendly_id%":"d9e1112d4798-haul-truck-driver","%breezy_created_date%":"2025-03-18T14:00:11.759Z","%breezy_updated_date%":"2025-07-10T12:59:36.051Z","%_wpgmp_location_city%":"Pacific","%_wpgmp_location_state%":"MO","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Pacific, MO, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"38.4819976","%_wpgmp_metabox_longitude%":"-90.7415194","%rank_math_internal_links_processed%":"1"}},"id":2283,"infowindow_disable":false},{"source":"post","title":"Lead Pipe Foreman","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Lead Pipe Foreman\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Lead Foreman Construction &amp; Site Development | Charlotte, NC Area Turner Staffing Group is partnered with a construction and site&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/lead-pipe-foreman\/\" name=\"Lead Pipe Foreman\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Lead Foreman Construction &amp; Site Development | Charlotte, NC Area Turner Staffing Group is partnered with a construction and site&hellip;","address":"Charlotte, NC, USA","location":{"lat":"35.2215548","city":"Charlotte","state":"NC","country":"United States","lng":"-80.840116","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/lead-pipe-foreman\/","zoom":19,"extra_fields":{"post_excerpt":"Lead Foreman Construction &amp; Site Development | Charlotte, NC Area Turner Staffing Group is partnered with a construction and site&hellip;","post_content":"<p><strong>Lead Foreman<\/strong><br>\n<em>Construction &amp; Site Development | Charlotte, NC Area<\/em><\/p>\n<p>Turner Staffing Group is partnered with a <strong>construction and site development company<\/strong> seeking a <strong>Lead Foreman<\/strong> to join their team. This individual will be responsible for overseeing daily operations, managing crews, and ensuring projects run smoothly and efficiently.<\/p>\n<h3><strong>Key Responsibilities:<\/strong><\/h3>\n<ul>\n<li>Oversee <strong>day-to-day operations<\/strong> on the jobsite, ensuring tasks are completed efficiently.<\/li>\n<li>Ensure all <strong>necessary tools and equipment<\/strong> are available for daily tasks.<\/li>\n<li><strong>Manage and train<\/strong> new laborers and Heavy Equipment Operators (HEO).<\/li>\n<li>Work closely with the <strong>Superintendent<\/strong> to ensure adequate manpower for each task.<\/li>\n<li>Coordinate with the Superintendent to ensure <strong>materials<\/strong> are available as needed.<\/li>\n<li><strong>Resolve conflicts and troubleshoot problems<\/strong>, escalating to the Superintendent when necessary.<\/li>\n<li><strong>Assign tasks<\/strong> to laborers and HEOs, ensuring workflow efficiency.<\/li>\n<li>Clearly <strong>communicate the daily plan<\/strong> to the labor force, keeping the team aligned with project goals.<\/li>\n<\/ul>\n<h3><strong>Qualifications &amp; Skills:<\/strong><\/h3>\n<ul>\n<li>Proven experience as a <strong>Foreman or similar leadership role<\/strong> in construction or site development.<\/li>\n<li>Strong knowledge of <strong>construction practices, equipment, and safety protocols<\/strong>.<\/li>\n<li>Ability to <strong>train and manage teams<\/strong> effectively.<\/li>\n<li>Strong problem-solving skills and <strong>ability to handle jobsite challenges<\/strong>.<\/li>\n<li>Excellent <strong>communication and coordination skills<\/strong>.<\/li>\n<\/ul>\n<p>This is a great opportunity for a hands-on leader looking to make an impact in <strong>construction and site development<\/strong>.<\/p>","post_title":"Lead Pipe Foreman","post_link":"https:\/\/turnerstaffing.com\/position\/lead-pipe-foreman\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Associate","%location_country%":"United States","%location_city%":"Charlotte","%location_state_id%":"NC","%location_state_name%":"North Carolina","%location_city_state%":"Charlotte, NC","%education%":"Unspecified","%department%":"Operations","%description%":"<p><strong>Lead Foreman<\/strong><br>\n<em>Construction &amp; Site Development | Charlotte, NC Area<\/em><\/p>\n<p>Turner Staffing Group is partnered with a <strong>construction and site development company<\/strong> seeking a <strong>Lead Foreman<\/strong> to join their team. This individual will be responsible for overseeing daily operations, managing crews, and ensuring projects run smoothly and efficiently.<\/p>\n<h3><strong>Key Responsibilities:<\/strong><\/h3>\n<ul>\n<li>Oversee <strong>day-to-day operations<\/strong> on the jobsite, ensuring tasks are completed efficiently.<\/li>\n<li>Ensure all <strong>necessary tools and equipment<\/strong> are available for daily tasks.<\/li>\n<li><strong>Manage and train<\/strong> new laborers and Heavy Equipment Operators (HEO).<\/li>\n<li>Work closely with the <strong>Superintendent<\/strong> to ensure adequate manpower for each task.<\/li>\n<li>Coordinate with the Superintendent to ensure <strong>materials<\/strong> are available as needed.<\/li>\n<li><strong>Resolve conflicts and troubleshoot problems<\/strong>, escalating to the Superintendent when necessary.<\/li>\n<li><strong>Assign tasks<\/strong> to laborers and HEOs, ensuring workflow efficiency.<\/li>\n<li>Clearly <strong>communicate the daily plan<\/strong> to the labor force, keeping the team aligned with project goals.<\/li>\n<\/ul>\n<h3><strong>Qualifications &amp; Skills:<\/strong><\/h3>\n<ul>\n<li>Proven experience as a <strong>Foreman or similar leadership role<\/strong> in construction or site development.<\/li>\n<li>Strong knowledge of <strong>construction practices, equipment, and safety protocols<\/strong>.<\/li>\n<li>Ability to <strong>train and manage teams<\/strong> effectively.<\/li>\n<li>Strong problem-solving skills and <strong>ability to handle jobsite challenges<\/strong>.<\/li>\n<li>Excellent <strong>communication and coordination skills<\/strong>.<\/li>\n<\/ul>\n<p>This is a great opportunity for a hands-on leader looking to make an impact in <strong>construction and site development<\/strong>.<\/p>","%category%":"Operations","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/dd3e32aef9ea-lead-pipe-foreman","%breezy_id%":"dd3e32aef9ea","%breezy_friendly_id%":"dd3e32aef9ea-lead-pipe-foreman","%breezy_created_date%":"2025-03-19T13:51:48.119Z","%breezy_updated_date%":"2025-06-19T18:52:39.314Z","%_wpgmp_location_city%":"Charlotte","%_wpgmp_location_state%":"NC","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Charlotte, NC, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"35.2215548","%_wpgmp_metabox_longitude%":"-80.840116","%rank_math_internal_links_processed%":"1"}},"id":2271,"infowindow_disable":false},{"source":"post","title":"Utility Superintendent","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Utility Superintendent\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Utility Superintendent Charlotte, NC Area Turner Staffing Group is partnered with a construction and development company in the Charlotte, NC&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/utility-superintendent\/\" name=\"Utility Superintendent\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Utility Superintendent Charlotte, NC Area Turner Staffing Group is partnered with a construction and development company in the Charlotte, NC&hellip;","address":"Greensboro, NC, USA","location":{"lat":"36.0725632","city":"Greensboro","state":"NC","country":"United States","lng":"-79.791534","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/utility-superintendent\/","zoom":19,"extra_fields":{"post_excerpt":"Utility Superintendent Charlotte, NC Area Turner Staffing Group is partnered with a construction and development company in the Charlotte, NC&hellip;","post_content":"<p><strong>Utility Superintendent<\/strong><br>\n<em>Charlotte, NC Area<\/em><\/p>\n<p>Turner Staffing Group is partnered with a construction and development company in the Charlotte, NC area seeking a <strong>Utility Superintendent<\/strong> to oversee crews and projects. This individual will play a key role in planning, coordinating, and executing utility infrastructure work while ensuring efficiency, safety, and cost management.<\/p>\n<h3><strong>Key Responsibilities:<\/strong><\/h3>\n<ul>\n<li>Develop and implement <strong>long-term jobsite plans<\/strong> to ensure efficient project execution.<\/li>\n<li>Oversee the <strong>layout of projected work<\/strong>, ensuring accuracy and compliance with project specifications.<\/li>\n<li><strong>Schedule material deliveries<\/strong> as necessary to maintain project timelines.<\/li>\n<li>Attend <strong>pre-construction and planning meetings<\/strong> throughout the project lifecycle.<\/li>\n<li><strong>Manage workforce efficiency<\/strong>, ensuring proper allocation of man-hours and overall jobsite cost control.<\/li>\n<li>Oversee and <strong>manage PDF and CAD files<\/strong>, ensuring accurate documentation and integration with project plans.<\/li>\n<li><strong>Resolve conflicts and issues<\/strong> that arise on-site, maintaining smooth project flow.<\/li>\n<li>Step in as <strong>Foreman when necessary<\/strong>, providing direct leadership and hands-on support.<\/li>\n<\/ul>\n<h3><strong>Qualifications &amp; Skills:<\/strong><\/h3>\n<ul>\n<li>Proven experience as a <strong>Utility Superintendent<\/strong> or in a similar supervisory role within <strong>construction or infrastructure development<\/strong>.<\/li>\n<li>Strong knowledge of <strong>utility installation, site layout, and project scheduling<\/strong>.<\/li>\n<li>Proficiency in <strong>reading and managing CAD and PDF files<\/strong> related to construction projects.<\/li>\n<li>Excellent problem-solving skills and ability to handle on-site <strong>conflicts<\/strong> effectively.<\/li>\n<li>Strong communication and leadership abilities, capable of <strong>coordinating multiple teams<\/strong>.<\/li>\n<li>Experience with <strong>budget management and cost control<\/strong>.<\/li>\n<\/ul>\n<p>This role is a great opportunity for a motivated leader to oversee <strong>essential utility projects<\/strong> in the Charlotte, NC area while ensuring quality and efficiency.<\/p>","post_title":"Utility Superintendent","post_link":"https:\/\/turnerstaffing.com\/position\/utility-superintendent\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Associate","%location_country%":"United States","%location_city%":"Greensboro","%location_state_id%":"NC","%location_state_name%":"North Carolina","%location_city_state%":"Greensboro, NC","%education%":"Unspecified","%department%":"Operations","%description%":"<p><strong>Utility Superintendent<\/strong><br>\n<em>Charlotte, NC Area<\/em><\/p>\n<p>Turner Staffing Group is partnered with a construction and development company in the Charlotte, NC area seeking a <strong>Utility Superintendent<\/strong> to oversee crews and projects. This individual will play a key role in planning, coordinating, and executing utility infrastructure work while ensuring efficiency, safety, and cost management.<\/p>\n<h3><strong>Key Responsibilities:<\/strong><\/h3>\n<ul>\n<li>Develop and implement <strong>long-term jobsite plans<\/strong> to ensure efficient project execution.<\/li>\n<li>Oversee the <strong>layout of projected work<\/strong>, ensuring accuracy and compliance with project specifications.<\/li>\n<li><strong>Schedule material deliveries<\/strong> as necessary to maintain project timelines.<\/li>\n<li>Attend <strong>pre-construction and planning meetings<\/strong> throughout the project lifecycle.<\/li>\n<li><strong>Manage workforce efficiency<\/strong>, ensuring proper allocation of man-hours and overall jobsite cost control.<\/li>\n<li>Oversee and <strong>manage PDF and CAD files<\/strong>, ensuring accurate documentation and integration with project plans.<\/li>\n<li><strong>Resolve conflicts and issues<\/strong> that arise on-site, maintaining smooth project flow.<\/li>\n<li>Step in as <strong>Foreman when necessary<\/strong>, providing direct leadership and hands-on support.<\/li>\n<\/ul>\n<h3><strong>Qualifications &amp; Skills:<\/strong><\/h3>\n<ul>\n<li>Proven experience as a <strong>Utility Superintendent<\/strong> or in a similar supervisory role within <strong>construction or infrastructure development<\/strong>.<\/li>\n<li>Strong knowledge of <strong>utility installation, site layout, and project scheduling<\/strong>.<\/li>\n<li>Proficiency in <strong>reading and managing CAD and PDF files<\/strong> related to construction projects.<\/li>\n<li>Excellent problem-solving skills and ability to handle on-site <strong>conflicts<\/strong> effectively.<\/li>\n<li>Strong communication and leadership abilities, capable of <strong>coordinating multiple teams<\/strong>.<\/li>\n<li>Experience with <strong>budget management and cost control<\/strong>.<\/li>\n<\/ul>\n<p>This role is a great opportunity for a motivated leader to oversee <strong>essential utility projects<\/strong> in the Charlotte, NC area while ensuring quality and efficiency.<\/p>","%category%":"Operations","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/6b68fb1bd42e-utility-superintendent","%breezy_id%":"6b68fb1bd42e","%breezy_friendly_id%":"6b68fb1bd42e-utility-superintendent","%breezy_created_date%":"2025-03-19T13:44:56.855Z","%breezy_updated_date%":"2025-06-19T18:52:55.856Z","%_wpgmp_location_city%":"Greensboro","%_wpgmp_location_state%":"NC","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Greensboro, NC, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"36.0725632","%_wpgmp_metabox_longitude%":"-79.791534","%rank_math_internal_links_processed%":"1"}},"id":2270,"infowindow_disable":false},{"source":"post","title":"Heavy Equipment Operator","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Heavy Equipment Operator\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Position Overview: We are seeking an experienced and safety-conscious Heavy Equipment Operator to join our team in the Winchester, VA&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/heavy-equipment-operator-4\/\" name=\"Heavy Equipment Operator\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Position Overview: We are seeking an experienced and safety-conscious Heavy Equipment Operator to join our team in the Winchester, VA&hellip;","address":"Winchester, VA, USA","location":{"lat":"39.1856597","city":"Winchester","state":"VA","country":"United States","lng":"-78.1633341","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/heavy-equipment-operator-4\/","zoom":19,"extra_fields":{"post_excerpt":"Position Overview: We are seeking an experienced and safety-conscious Heavy Equipment Operator to join our team in the Winchester, VA&hellip;","post_content":"<p><strong>Position Overview:<\/strong><br>\nWe are seeking an experienced and safety-conscious Heavy Equipment Operator to join our team in the Winchester, VA area. This role will be responsible for operating D6 Dozers and 352 Excavators in the wet utilities sector of civil construction. The ideal candidate will have a strong background in operating heavy equipment, particularly in the excavation and earthmoving aspects of utility installation, trenching, and site preparation.<\/p>\n<p><strong>Key Responsibilities:<\/strong><\/p>\n<ul>\n<li><strong>Operate Heavy Equipment:<\/strong> Efficiently and safely operate D6 Dozers and 352 Excavators for grading, digging, trenching, and excavation tasks in the wet utilities civil construction environment.<\/li>\n<li><strong>Excavation &amp; Site Preparation:<\/strong> Perform excavation duties for utility installation, including digging trenches for water, sewer, stormwater, and other underground utilities.<\/li>\n<li><strong>Material Handling:<\/strong> Load, move, and place materials such as soil, gravel, and rocks using the dozer and excavator.<\/li>\n<li><strong>Follow Plans &amp; Specifications:<\/strong> Work closely with project managers and site supervisors to ensure operations follow blueprints, design plans, and regulatory requirements.<\/li>\n<li><strong>Safety Compliance:<\/strong> Adhere to all safety protocols and regulations to maintain a safe work environment. Perform daily inspections of equipment and perform minor maintenance as needed.<\/li>\n<li><strong>Site Coordination:<\/strong> Work with other operators, laborers, and supervisors to maintain the efficiency and effectiveness of daily operations.<\/li>\n<li><strong>Routine Maintenance:<\/strong> Conduct routine equipment checks, report any mechanical issues, and assist with minor repairs or maintenance on machines.<\/li>\n<li><strong>Environmental Considerations:<\/strong> Ensure environmental regulations and best practices are followed, especially when working near water sources or sensitive areas.<\/li>\n<\/ul>\n<p><strong>Qualifications:<\/strong><\/p>\n<ul>\n<li><strong>Experience:<\/strong> Minimum of 3-5 years of experience in operating heavy equipment, specifically D6 Dozers and 352 Excavators, in a civil construction or wet utilities environment.<\/li>\n<li><strong>Certifications:<\/strong> Valid heavy equipment operator certification or equivalent training. OSHA or other relevant safety training is a plus.<\/li>\n<li><strong>Knowledge:<\/strong> Strong understanding of civil construction practices, wet utilities installation, and safety regulations.<\/li>\n<li><strong>Physical Requirements:<\/strong> Ability to work in outdoor environments, including inclement weather conditions. Must be able to lift heavy materials and work in physically demanding conditions.<\/li>\n<li><strong>Skills:<\/strong> Excellent hand-eye coordination, good mechanical aptitude, and ability to operate equipment safely and efficiently.<\/li>\n<li><strong>Communication:<\/strong> Strong communication skills, both verbal and written, for effective collaboration with team members and supervisors.<\/li>\n<li><strong>Driver\u2019s License:<\/strong> Valid driver\u2019s license with a clean driving record. CDL is a plus but not required.<\/li><\/ul>","post_title":"Heavy Equipment Operator","post_link":"https:\/\/turnerstaffing.com\/position\/heavy-equipment-operator-4\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Mid Level","%location_country%":"United States","%location_city%":"Winchester","%location_state_id%":"VA","%location_state_name%":"Virginia","%location_city_state%":"Winchester, VA","%education%":"Unspecified","%department%":"","%description%":"<p><strong>Position Overview:<\/strong><br>\nWe are seeking an experienced and safety-conscious Heavy Equipment Operator to join our team in the Winchester, VA area. This role will be responsible for operating D6 Dozers and 352 Excavators in the wet utilities sector of civil construction. The ideal candidate will have a strong background in operating heavy equipment, particularly in the excavation and earthmoving aspects of utility installation, trenching, and site preparation.<\/p>\n<p><strong>Key Responsibilities:<\/strong><\/p>\n<ul>\n<li><strong>Operate Heavy Equipment:<\/strong> Efficiently and safely operate D6 Dozers and 352 Excavators for grading, digging, trenching, and excavation tasks in the wet utilities civil construction environment.<\/li>\n<li><strong>Excavation &amp; Site Preparation:<\/strong> Perform excavation duties for utility installation, including digging trenches for water, sewer, stormwater, and other underground utilities.<\/li>\n<li><strong>Material Handling:<\/strong> Load, move, and place materials such as soil, gravel, and rocks using the dozer and excavator.<\/li>\n<li><strong>Follow Plans &amp; Specifications:<\/strong> Work closely with project managers and site supervisors to ensure operations follow blueprints, design plans, and regulatory requirements.<\/li>\n<li><strong>Safety Compliance:<\/strong> Adhere to all safety protocols and regulations to maintain a safe work environment. Perform daily inspections of equipment and perform minor maintenance as needed.<\/li>\n<li><strong>Site Coordination:<\/strong> Work with other operators, laborers, and supervisors to maintain the efficiency and effectiveness of daily operations.<\/li>\n<li><strong>Routine Maintenance:<\/strong> Conduct routine equipment checks, report any mechanical issues, and assist with minor repairs or maintenance on machines.<\/li>\n<li><strong>Environmental Considerations:<\/strong> Ensure environmental regulations and best practices are followed, especially when working near water sources or sensitive areas.<\/li>\n<\/ul>\n<p><strong>Qualifications:<\/strong><\/p>\n<ul>\n<li><strong>Experience:<\/strong> Minimum of 3-5 years of experience in operating heavy equipment, specifically D6 Dozers and 352 Excavators, in a civil construction or wet utilities environment.<\/li>\n<li><strong>Certifications:<\/strong> Valid heavy equipment operator certification or equivalent training. OSHA or other relevant safety training is a plus.<\/li>\n<li><strong>Knowledge:<\/strong> Strong understanding of civil construction practices, wet utilities installation, and safety regulations.<\/li>\n<li><strong>Physical Requirements:<\/strong> Ability to work in outdoor environments, including inclement weather conditions. Must be able to lift heavy materials and work in physically demanding conditions.<\/li>\n<li><strong>Skills:<\/strong> Excellent hand-eye coordination, good mechanical aptitude, and ability to operate equipment safely and efficiently.<\/li>\n<li><strong>Communication:<\/strong> Strong communication skills, both verbal and written, for effective collaboration with team members and supervisors.<\/li>\n<li><strong>Driver\u2019s License:<\/strong> Valid driver\u2019s license with a clean driving record. CDL is a plus but not required.<\/li><\/ul>","%category%":"Operations","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/9f51d8b20520-heavy-equipment-operator","%breezy_id%":"9f51d8b20520","%breezy_friendly_id%":"9f51d8b20520-heavy-equipment-operator","%breezy_created_date%":"2025-03-10T16:51:30.607Z","%breezy_updated_date%":"2025-06-11T14:11:57.632Z","%_wpgmp_location_city%":"Winchester","%_wpgmp_location_state%":"VA","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Winchester, VA, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"39.1856597","%_wpgmp_metabox_longitude%":"-78.1633341","%rank_math_internal_links_processed%":"1"}},"id":2233,"infowindow_disable":false},{"source":"post","title":"Heavy Equipment Fuel Lube Technician","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Heavy Equipment Fuel Lube Technician\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    About Us:Turner Staffing Group, in collaboration with our esteemed mining partner in Kershaw, South Carolina, is actively seeking experienced maintenance&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/heavy-equipment-fuel-lube-technician\/\" name=\"Heavy Equipment Fuel Lube Technician\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"About Us:Turner Staffing Group, in collaboration with our esteemed mining partner in Kershaw, South Carolina, is actively seeking experienced maintenance&hellip;","address":"Kershaw, SC, USA","location":{"lat":"34.5518201","city":"Kershaw","state":"SC","country":"United States","lng":"-80.5836836","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/heavy-equipment-fuel-lube-technician\/","zoom":19,"extra_fields":{"post_excerpt":"About Us:Turner Staffing Group, in collaboration with our esteemed mining partner in Kershaw, South Carolina, is actively seeking experienced maintenance&hellip;","post_content":"<p><strong>About Us:<\/strong><br>Turner Staffing Group, in collaboration with our esteemed mining partner in Kershaw, South Carolina, is actively seeking experienced maintenance professionals to join our dynamic team. As a leading force in the mining industry, we are dedicated to fostering a culture of excellence, safety, and innovation.<br><\/p>\n<p>We are looking for a dynamic and talented professional to fill a&nbsp;<strong>Fuel &amp; Lube Technician<\/strong>&nbsp;role at our fast-growing, forward thinking mining services company.<\/p>\n<p>This person will function as a&nbsp;<strong>Fuel &amp; Lube Technician<\/strong> and must be willing to do, learn, perform and improve any maintenance task. Tasks will be defined and evolve in all areas of mining operations to ensure preventative maintenance is practiced, repairs, equipment runs in the area of responsibility. This is an opportunity to work as part of the operations team in a safe, productive, and fun environment.<\/p>\n<p><strong>Essential Skills &amp; Knowledge<\/strong><\/p>\n<p>\u2022 Follow a consistent and regular schedule to perform various types of maintenance on heavy equipment and various pieces of machinery&nbsp;<\/p>\n<p>\u2022 Perform minor repairs on equipment using tools, machine tools and measuring instruments&nbsp;<\/p>\n<p>\u2022 Conduct oil changes, lubrication of equipment, tire replacements, hose repairs, battery replacements and assorted services&nbsp;<\/p>\n<p>\u2022 Operate and test equipment&nbsp;<\/p>\n<p>\u2022 Produce detailed service reports and repair logs&nbsp;<\/p>\n<p>\u2022 Follow all established procedures and protocols&nbsp;<\/p>\n<p>\u2022 Build positive relationships with internal and external teams<\/p>\n<p>\u2022 Perform additional duties as assigned<\/p>","post_title":"Heavy Equipment Fuel Lube Technician","post_link":"https:\/\/turnerstaffing.com\/position\/heavy-equipment-fuel-lube-technician\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"","%location_country%":"United States","%location_city%":"Kershaw","%location_state_id%":"SC","%location_state_name%":"South Carolina","%location_city_state%":"Kershaw, SC","%education%":"","%department%":"","%description%":"<p><strong>About Us:<\/strong><br>Turner Staffing Group, in collaboration with our esteemed mining partner in Kershaw, South Carolina, is actively seeking experienced maintenance professionals to join our dynamic team. As a leading force in the mining industry, we are dedicated to fostering a culture of excellence, safety, and innovation.<br><\/p>\n<p>We are looking for a dynamic and talented professional to fill a&nbsp;<strong>Fuel &amp; Lube Technician<\/strong>&nbsp;role at our fast-growing, forward thinking mining services company.<\/p>\n<p>This person will function as a&nbsp;<strong>Fuel &amp; Lube Technician<\/strong> and must be willing to do, learn, perform and improve any maintenance task. Tasks will be defined and evolve in all areas of mining operations to ensure preventative maintenance is practiced, repairs, equipment runs in the area of responsibility. This is an opportunity to work as part of the operations team in a safe, productive, and fun environment.<\/p>\n<p><strong>Essential Skills &amp; Knowledge<\/strong><\/p>\n<p>\u2022 Follow a consistent and regular schedule to perform various types of maintenance on heavy equipment and various pieces of machinery&nbsp;<\/p>\n<p>\u2022 Perform minor repairs on equipment using tools, machine tools and measuring instruments&nbsp;<\/p>\n<p>\u2022 Conduct oil changes, lubrication of equipment, tire replacements, hose repairs, battery replacements and assorted services&nbsp;<\/p>\n<p>\u2022 Operate and test equipment&nbsp;<\/p>\n<p>\u2022 Produce detailed service reports and repair logs&nbsp;<\/p>\n<p>\u2022 Follow all established procedures and protocols&nbsp;<\/p>\n<p>\u2022 Build positive relationships with internal and external teams<\/p>\n<p>\u2022 Perform additional duties as assigned<\/p>","%category%":"","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/87de073f2f25-heavy-equipment-fuel-lube-technician","%breezy_id%":"87de073f2f25","%breezy_friendly_id%":"87de073f2f25-heavy-equipment-fuel-lube-technician","%breezy_created_date%":"2025-02-04T21:47:40.868Z","%breezy_updated_date%":"2025-05-08T19:21:56.672Z","%_wpgmp_location_city%":"Kershaw","%_wpgmp_location_state%":"SC","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Kershaw, SC, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"34.5518201","%_wpgmp_metabox_longitude%":"-80.5836836","%rank_math_internal_links_processed%":"1"}},"id":2221,"infowindow_disable":false},{"source":"post","title":"Loader Operator","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Loader Operator\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Production Loader Operator Company: Turner Staffing Group (Partnered with a Local Mining Company) Position Type: Full-Time Salary: Competitive, based on&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/loader-operator\/\" name=\"Loader Operator\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Production Loader Operator Company: Turner Staffing Group (Partnered with a Local Mining Company) Position Type: Full-Time Salary: Competitive, based on&hellip;","address":"Kershaw, SC, USA","location":{"lat":"34.5518201","city":"Kershaw","state":"SC","country":"United States","lng":"-80.5836836","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/loader-operator\/","zoom":19,"extra_fields":{"post_excerpt":"Production Loader Operator Company: Turner Staffing Group (Partnered with a Local Mining Company) Position Type: Full-Time Salary: Competitive, based on&hellip;","post_content":"<p><strong><u>Production Loader Operator<\/u><\/strong><\/p><p><strong>Company:<\/strong> Turner Staffing Group (Partnered with a Local Mining Company)<\/p>\n<p><strong>Position Type:<\/strong> Full-Time<\/p>\n<p><strong>Salary:<\/strong> Competitive, based on experience<\/p>\n<h4>Job Overview:<\/h4>\n<p>Turner Staffing Group is seeking a skilled Production Loader Operator to join our partner\u2019s mining team in Kershaw, South Carolina. The ideal candidate will have experience operating loaders in a mining environment and a strong understanding of mining production processes. This role involves operating heavy equipment to move materials, load trucks, and support overall production activities.<\/p>\n<h4>Key Responsibilities:<\/h4>\n<ul><li>Operate production loaders to move, load, and handle materials such as ore, rock, and other mined materials.<\/li><li>Perform pre-operational checks and regular maintenance on loaders to ensure safety and functionality.<\/li><li>Work closely with other operators and team members to coordinate production activities.<\/li><li>Maintain a clean and organized work environment around the loading area.<\/li><li>Follow safety guidelines and company policies to ensure a safe work environment.<\/li><li>Monitor equipment performance and report any issues or necessary repairs to maintenance personnel.<\/li><li>Maintain accurate records of material movements and loader usage.<\/li><li>Assist with other mining operations and tasks as needed.<\/li><\/ul>\n<h4>Qualifications:<\/h4>\n<ul><li>High school diploma or equivalent.<\/li><li>Proven experience as a loader operator, preferably in a mining environment.<\/li><li>Strong knowledge of loader operations, safety practices, and basic maintenance.<\/li><li>Ability to read and interpret production schedules and work instructions.<\/li><li>Good physical condition with the ability to work in various weather conditions.<\/li><li>Strong communication and teamwork skills.<\/li><li>Attention to detail and commitment to safety.<\/li><li>Valid driver\u2019s license and reliable transportation.<\/li><\/ul>\n<h4>Preferred Qualifications:<\/h4>\n<ul><li>Experience in metal mining or a similar heavy industry.<\/li><li>Certification or training in loader operation.<\/li><li>Familiarity with mining production processes and equipment.<\/li><\/ul>\n<h4>Benefits:<\/h4>\n<ul><li>Competitive salary and comprehensive benefits package.<\/li><li>Opportunities for professional growth and advancement.<\/li><li>Health, dental, and vision insurance.<\/li><li>Retirement savings plan with company match.<\/li><li>Supportive and inclusive work environment.<\/li><\/ul><p><strong><u><br><\/u><\/strong><\/p>","post_title":"Loader Operator","post_link":"https:\/\/turnerstaffing.com\/position\/loader-operator\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Associate","%location_country%":"United States","%location_city%":"Kershaw","%location_state_id%":"SC","%location_state_name%":"South Carolina","%location_city_state%":"Kershaw, SC","%education%":"Unspecified","%department%":"Operations","%description%":"<p><strong><u>Production Loader Operator<\/u><\/strong><\/p><p><strong>Company:<\/strong> Turner Staffing Group (Partnered with a Local Mining Company)<\/p>\n<p><strong>Position Type:<\/strong> Full-Time<\/p>\n<p><strong>Salary:<\/strong> Competitive, based on experience<\/p>\n<h4>Job Overview:<\/h4>\n<p>Turner Staffing Group is seeking a skilled Production Loader Operator to join our partner\u2019s mining team in Kershaw, South Carolina. The ideal candidate will have experience operating loaders in a mining environment and a strong understanding of mining production processes. This role involves operating heavy equipment to move materials, load trucks, and support overall production activities.<\/p>\n<h4>Key Responsibilities:<\/h4>\n<ul><li>Operate production loaders to move, load, and handle materials such as ore, rock, and other mined materials.<\/li><li>Perform pre-operational checks and regular maintenance on loaders to ensure safety and functionality.<\/li><li>Work closely with other operators and team members to coordinate production activities.<\/li><li>Maintain a clean and organized work environment around the loading area.<\/li><li>Follow safety guidelines and company policies to ensure a safe work environment.<\/li><li>Monitor equipment performance and report any issues or necessary repairs to maintenance personnel.<\/li><li>Maintain accurate records of material movements and loader usage.<\/li><li>Assist with other mining operations and tasks as needed.<\/li><\/ul>\n<h4>Qualifications:<\/h4>\n<ul><li>High school diploma or equivalent.<\/li><li>Proven experience as a loader operator, preferably in a mining environment.<\/li><li>Strong knowledge of loader operations, safety practices, and basic maintenance.<\/li><li>Ability to read and interpret production schedules and work instructions.<\/li><li>Good physical condition with the ability to work in various weather conditions.<\/li><li>Strong communication and teamwork skills.<\/li><li>Attention to detail and commitment to safety.<\/li><li>Valid driver\u2019s license and reliable transportation.<\/li><\/ul>\n<h4>Preferred Qualifications:<\/h4>\n<ul><li>Experience in metal mining or a similar heavy industry.<\/li><li>Certification or training in loader operation.<\/li><li>Familiarity with mining production processes and equipment.<\/li><\/ul>\n<h4>Benefits:<\/h4>\n<ul><li>Competitive salary and comprehensive benefits package.<\/li><li>Opportunities for professional growth and advancement.<\/li><li>Health, dental, and vision insurance.<\/li><li>Retirement savings plan with company match.<\/li><li>Supportive and inclusive work environment.<\/li><\/ul><p><strong><u><br><\/u><\/strong><\/p>","%category%":"Operations","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/911905533756-loader-operator","%breezy_id%":"911905533756","%breezy_friendly_id%":"911905533756-loader-operator","%breezy_created_date%":"2024-08-27T13:55:50.627Z","%breezy_updated_date%":"2025-06-11T14:12:50.589Z","%_wpgmp_location_city%":"Kershaw","%_wpgmp_location_state%":"SC","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Kershaw, SC, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"34.5518201","%_wpgmp_metabox_longitude%":"-80.5836836","%rank_math_internal_links_processed%":"1"}},"id":2220,"infowindow_disable":false},{"source":"post","title":"Heavy Equipment Operator","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Heavy Equipment Operator\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Job Title: Heavy Equipment Operator Company: Turner Staffing Group Location: Kershaw, South Carolina, USA Position Type: Full-Time About Us: Turner&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/heavy-equipment-operator\/\" name=\"Heavy Equipment Operator\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Job Title: Heavy Equipment Operator Company: Turner Staffing Group Location: Kershaw, South Carolina, USA Position Type: Full-Time About Us: Turner&hellip;","address":"Kershaw, SC, USA","location":{"lat":"34.5518201","city":"Kershaw","state":"SC","country":"United States","lng":"-80.5836836","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/heavy-equipment-operator\/","zoom":19,"extra_fields":{"post_excerpt":"Job Title: Heavy Equipment Operator Company: Turner Staffing Group Location: Kershaw, South Carolina, USA Position Type: Full-Time About Us: Turner&hellip;","post_content":"<p><strong>Job Title:<\/strong> Heavy Equipment Operator<\/p>\n<p><strong>Company:<\/strong> Turner Staffing Group<\/p>\n<p><strong>Location:<\/strong> Kershaw, South Carolina, USA<\/p>\n<p><strong>Position Type:<\/strong> Full-Time<\/p>\n<p><strong>About Us:<\/strong>\nTurner Staffing Group, in collaboration with our esteemed mining partner in Kershaw, South Carolina, is actively seeking experienced Heavy Equipment Operators to join our dynamic team. As a leading force in the mining industry, we are dedicated to fostering a culture of excellence, safety, and innovation.<\/p>\n<p><strong>Job Overview:<\/strong>\nWe are looking for skilled and safety-conscious Heavy Equipment Operators to contribute to the success of our mining operations. The ideal candidates will have hands-on experience operating a variety of heavy equipment, ensuring the efficient and safe extraction of minerals from the site.<\/p>\n<p><strong>Responsibilities:<\/strong><\/p>\n<ol><li><strong>Equipment Operation:<\/strong><ul><li>Safely operate heavy equipment, including but not limited to bulldozers, excavators, loaders, and haul trucks.<\/li><li>Execute tasks such as grading, digging, loading, and transporting materials as per project requirements.<\/li><\/ul><\/li><li><strong>Safety Compliance:<\/strong><ul><li>Adhere to all safety protocols and guidelines to ensure a secure work environment.<\/li><li>Conduct routine equipment inspections and report any issues promptly.<\/li><\/ul><\/li><li><strong>Efficiency and Productivity:<\/strong><ul><li>Work collaboratively with the mining team to optimize workflow and maximize production efficiency.<\/li><li>Meet project deadlines and production targets while maintaining high-quality standards.<\/li><\/ul><\/li><li><strong>Communication:<\/strong><ul><li>Effectively communicate with supervisors, colleagues, and other team members to ensure seamless project coordination.<\/li><li>Report any operational challenges or concerns in a timely manner.<\/li><\/ul><\/li><li><strong>Maintenance Support:<\/strong><ul><li>Collaborate with the maintenance team to facilitate regular equipment maintenance and repairs.<\/li><li>Assist in troubleshooting equipment issues and participate in scheduled maintenance activities.<\/li><\/ul><\/li><\/ol>\n<p><strong>Requirements:<\/strong><\/p>\n<ul><li>Proven experience as a Heavy Equipment Operator in a mining or similar industry.<\/li><li>Familiarity with safety regulations and commitment to safe work practices.<\/li><li>Ability to operate various heavy equipment efficiently and skillfully.<\/li><li>Strong communication and teamwork skills.<\/li><\/ul>\n<p><strong>Education and Certifications:<\/strong><\/p>\n<ul><li>High school diploma or equivalent.<\/li><li>Relevant certifications for heavy equipment operation.<\/li><li>MSHA experience preferred.&nbsp;<\/li><\/ul>\n<p><strong>Benefits:<\/strong><\/p>\n<ul><li>Competitive salary<\/li><li>Health, dental, and vision insurance<\/li><li>Retirement savings plan<\/li><\/ul>","post_title":"Heavy Equipment Operator","post_link":"https:\/\/turnerstaffing.com\/position\/heavy-equipment-operator\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Associate","%location_country%":"United States","%location_city%":"Kershaw","%location_state_id%":"SC","%location_state_name%":"South Carolina","%location_city_state%":"Kershaw, SC","%education%":"High School or equivalent","%department%":"Operations","%description%":"<p><strong>Job Title:<\/strong> Heavy Equipment Operator<\/p>\n<p><strong>Company:<\/strong> Turner Staffing Group<\/p>\n<p><strong>Location:<\/strong> Kershaw, South Carolina, USA<\/p>\n<p><strong>Position Type:<\/strong> Full-Time<\/p>\n<p><strong>About Us:<\/strong>\nTurner Staffing Group, in collaboration with our esteemed mining partner in Kershaw, South Carolina, is actively seeking experienced Heavy Equipment Operators to join our dynamic team. As a leading force in the mining industry, we are dedicated to fostering a culture of excellence, safety, and innovation.<\/p>\n<p><strong>Job Overview:<\/strong>\nWe are looking for skilled and safety-conscious Heavy Equipment Operators to contribute to the success of our mining operations. The ideal candidates will have hands-on experience operating a variety of heavy equipment, ensuring the efficient and safe extraction of minerals from the site.<\/p>\n<p><strong>Responsibilities:<\/strong><\/p>\n<ol><li><strong>Equipment Operation:<\/strong><ul><li>Safely operate heavy equipment, including but not limited to bulldozers, excavators, loaders, and haul trucks.<\/li><li>Execute tasks such as grading, digging, loading, and transporting materials as per project requirements.<\/li><\/ul><\/li><li><strong>Safety Compliance:<\/strong><ul><li>Adhere to all safety protocols and guidelines to ensure a secure work environment.<\/li><li>Conduct routine equipment inspections and report any issues promptly.<\/li><\/ul><\/li><li><strong>Efficiency and Productivity:<\/strong><ul><li>Work collaboratively with the mining team to optimize workflow and maximize production efficiency.<\/li><li>Meet project deadlines and production targets while maintaining high-quality standards.<\/li><\/ul><\/li><li><strong>Communication:<\/strong><ul><li>Effectively communicate with supervisors, colleagues, and other team members to ensure seamless project coordination.<\/li><li>Report any operational challenges or concerns in a timely manner.<\/li><\/ul><\/li><li><strong>Maintenance Support:<\/strong><ul><li>Collaborate with the maintenance team to facilitate regular equipment maintenance and repairs.<\/li><li>Assist in troubleshooting equipment issues and participate in scheduled maintenance activities.<\/li><\/ul><\/li><\/ol>\n<p><strong>Requirements:<\/strong><\/p>\n<ul><li>Proven experience as a Heavy Equipment Operator in a mining or similar industry.<\/li><li>Familiarity with safety regulations and commitment to safe work practices.<\/li><li>Ability to operate various heavy equipment efficiently and skillfully.<\/li><li>Strong communication and teamwork skills.<\/li><\/ul>\n<p><strong>Education and Certifications:<\/strong><\/p>\n<ul><li>High school diploma or equivalent.<\/li><li>Relevant certifications for heavy equipment operation.<\/li><li>MSHA experience preferred.&nbsp;<\/li><\/ul>\n<p><strong>Benefits:<\/strong><\/p>\n<ul><li>Competitive salary<\/li><li>Health, dental, and vision insurance<\/li><li>Retirement savings plan<\/li><\/ul>","%category%":"Operations","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/069e55e8d946-heavy-equipment-operator","%breezy_id%":"069e55e8d946","%breezy_friendly_id%":"069e55e8d946-heavy-equipment-operator","%breezy_created_date%":"2024-02-28T15:16:25.397Z","%breezy_updated_date%":"2025-06-11T14:11:37.623Z","%_wpgmp_location_city%":"Kershaw","%_wpgmp_location_state%":"SC","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Kershaw, SC, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"34.5518201","%_wpgmp_metabox_longitude%":"-80.5836836","%rank_math_internal_links_processed%":"1"}},"id":2217,"infowindow_disable":false},{"source":"post","title":"Utility Operator (Excavator Operator)","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Utility Operator (Excavator Operator)\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    We are actively seeking a Lead Excavator Operator with pipeline experience to work with us in the Charlotte, NC area.&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/utility-operator-excavator-operator\/\" name=\"Utility Operator (Excavator Operator)\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"We are actively seeking a Lead Excavator Operator with pipeline experience to work with us in the Charlotte, NC area.&hellip;","address":"Charlotte, NC, USA","location":{"lat":"35.2215548","city":"Charlotte","state":"NC","country":"United States","lng":"-80.840116","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/utility-operator-excavator-operator\/","zoom":19,"extra_fields":{"post_excerpt":"We are actively seeking a Lead Excavator Operator with pipeline experience to work with us in the Charlotte, NC area.&hellip;","post_content":"<p>We are actively seeking a Lead Excavator Operator with pipeline experience to work with us in the Charlotte, NC area. This position will work under the direction of a foreman or superintendent and collaborate with a team of construction professionals to ensure successful utility installation projects.<\/p>\n<p><strong>Essential Duties &amp; Responsibilities:<\/strong><\/p>\n<ul><li>Communicate professionally with supervisors, teammates, contractors, clients, and vendors.<\/li><li>Understand, interpret, and follow goals and directions from foreman or superintendent.<\/li><li>Maintain cleanliness of all equipment.<\/li><li>Attend work regularly during assigned work hours or any other schedule as required.<\/li><li>Willingness to work overtime or on Saturdays as needed.<\/li><li>Participate in necessary training sessions.<\/li><\/ul>\n<p><strong>Other Duties &amp; Responsibilities:<\/strong><\/p>\n<ul><li>Assist with other tasks as needed, including supporting other roles on the crew.<\/li><\/ul>\n<p><strong>Experience &amp; Requirements:<\/strong><\/p>\n<ul><li>At least two years of experience operating excavators for pipeline work, including digging inside trench boxes and setting heavy loads such as precast structures and pipe.<\/li><li>Familiarity with OSHA Trenching and Shoring requirements.<\/li><li>Ability to read and understand grade stakes.<\/li><li>Must be able to work Monday through Friday, 7 AM \u2013 5:30 PM, and Saturdays when needed.<\/li><li>Strong communication skills and the ability to work effectively with supervisors and teammates.<\/li><li>Reliable transportation.<\/li><li>Ability to pass a pre-employment drug test and background screening.<\/li><li>Must be 18 years of age or older.<\/li><\/ul>\n<p><strong>Physical Demands:<\/strong><\/p>\n<ul><li>Able to stand\/sit for extended periods, as well as stoop, kneel, walk, bend, crouch, lift, and crawl.<\/li><li>Able to climb on and off equipment safely.<\/li><li>Able to lift 40-80 lbs regularly.<\/li><li>Comfortable working outdoors in varying weather conditions.<\/li><li>Able to use hands, arms, and feet for repetitive lifting and carrying of materials.<\/li><\/ul>\n<p><strong>Company Benefits:<\/strong><\/p>\n<ul><li>Competitive pay (based on experience)<\/li><li>Medical insurance<\/li><li>Short-term disability<\/li><li>Group term life insurance<\/li><li>Voluntary dental, vision, and life insurance<\/li><li>Voluntary long-term disability<\/li><li>401(k) plan with company match<\/li><li>Paid vacation, holidays, and leave<\/li><li>Profit-sharing program<\/li><li>Free training programs<\/li><\/ul>","post_title":"Utility Operator (Excavator Operator)","post_link":"https:\/\/turnerstaffing.com\/position\/utility-operator-excavator-operator\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"","%location_country%":"United States","%location_city%":"Charlotte","%location_state_id%":"NC","%location_state_name%":"North Carolina","%location_city_state%":"Charlotte, NC","%education%":"","%department%":"","%description%":"<p>We are actively seeking a Lead Excavator Operator with pipeline experience to work with us in the Charlotte, NC area. This position will work under the direction of a foreman or superintendent and collaborate with a team of construction professionals to ensure successful utility installation projects.<\/p>\n<p><strong>Essential Duties &amp; Responsibilities:<\/strong><\/p>\n<ul><li>Communicate professionally with supervisors, teammates, contractors, clients, and vendors.<\/li><li>Understand, interpret, and follow goals and directions from foreman or superintendent.<\/li><li>Maintain cleanliness of all equipment.<\/li><li>Attend work regularly during assigned work hours or any other schedule as required.<\/li><li>Willingness to work overtime or on Saturdays as needed.<\/li><li>Participate in necessary training sessions.<\/li><\/ul>\n<p><strong>Other Duties &amp; Responsibilities:<\/strong><\/p>\n<ul><li>Assist with other tasks as needed, including supporting other roles on the crew.<\/li><\/ul>\n<p><strong>Experience &amp; Requirements:<\/strong><\/p>\n<ul><li>At least two years of experience operating excavators for pipeline work, including digging inside trench boxes and setting heavy loads such as precast structures and pipe.<\/li><li>Familiarity with OSHA Trenching and Shoring requirements.<\/li><li>Ability to read and understand grade stakes.<\/li><li>Must be able to work Monday through Friday, 7 AM \u2013 5:30 PM, and Saturdays when needed.<\/li><li>Strong communication skills and the ability to work effectively with supervisors and teammates.<\/li><li>Reliable transportation.<\/li><li>Ability to pass a pre-employment drug test and background screening.<\/li><li>Must be 18 years of age or older.<\/li><\/ul>\n<p><strong>Physical Demands:<\/strong><\/p>\n<ul><li>Able to stand\/sit for extended periods, as well as stoop, kneel, walk, bend, crouch, lift, and crawl.<\/li><li>Able to climb on and off equipment safely.<\/li><li>Able to lift 40-80 lbs regularly.<\/li><li>Comfortable working outdoors in varying weather conditions.<\/li><li>Able to use hands, arms, and feet for repetitive lifting and carrying of materials.<\/li><\/ul>\n<p><strong>Company Benefits:<\/strong><\/p>\n<ul><li>Competitive pay (based on experience)<\/li><li>Medical insurance<\/li><li>Short-term disability<\/li><li>Group term life insurance<\/li><li>Voluntary dental, vision, and life insurance<\/li><li>Voluntary long-term disability<\/li><li>401(k) plan with company match<\/li><li>Paid vacation, holidays, and leave<\/li><li>Profit-sharing program<\/li><li>Free training programs<\/li><\/ul>","%category%":"","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/1c988197c1ae-utility-operator-excavator-operator","%breezy_id%":"1c988197c1ae","%breezy_friendly_id%":"1c988197c1ae-utility-operator-excavator-operator","%breezy_created_date%":"2025-03-04T18:11:14.690Z","%breezy_updated_date%":"2025-06-11T14:17:10.013Z","%_wpgmp_location_city%":"Charlotte","%_wpgmp_location_state%":"NC","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Charlotte, NC, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"35.2215548","%_wpgmp_metabox_longitude%":"-80.840116","%rank_math_internal_links_processed%":"1"}},"id":2214,"infowindow_disable":false},{"source":"post","title":"Project Superintendent- Utilities","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Project Superintendent- Utilities\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    The Project Superintendent is responsible for overseeing the on-site execution of projects, managing day-to-day construction activities, ensuring quality control, and&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/project-superintendent-utilities\/\" name=\"Project Superintendent- Utilities\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"The Project Superintendent is responsible for overseeing the on-site execution of projects, managing day-to-day construction activities, ensuring quality control, and&hellip;","address":"Harmony, MN, USA","location":{"lat":"43.5551811","city":"Harmony","state":"MN","country":"United States","lng":"-92.0052837","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/project-superintendent-utilities\/","zoom":19,"extra_fields":{"post_excerpt":"The Project Superintendent is responsible for overseeing the on-site execution of projects, managing day-to-day construction activities, ensuring quality control, and&hellip;","post_content":"<p>The Project Superintendent is responsible for overseeing the on-site execution of projects, managing day-to-day construction activities, ensuring quality control, and maintaining strong coordination between the field team, Project Administrator, and Project Manager. The Superintendent ensures projects are completed safely, on-time, and within budget while upholding the company\u2019s mission to transform lives.<\/p>\n<p>WHAT SKILLS DO I NEED TO DO THIS JOB EXTRAORDINARILY WELL?<\/p>\n<p>Skills required:<\/p>\n<p>- 5-7 years experience in coordinating and leading plow and drill crews in construction.<\/p>\n<p>- The ability to lead crews with safety as the top priority, including leading the morning meeting with a clear path forward<\/p>\n<p>- Strong organizational skills and a keen eye for detail.<\/p>\n<p>- Excellent communication and professional skills.<\/p>\n<p>- A \u201cI will attack this problem\u201d mindset.<\/p>\n<p>- Understanding of underground cable systems- ie. fiber networks, utility grids, and construction processes.<\/p>\n<p>- Must be able to create and maintain day-to-day processes involving production reporting, ensuring schedules and budget, and maintaining equipment.<\/p>\n<p>- Work closely with the Project Manager to ensure proper staffing.<\/p>\n<p>- Must be a self-starter, bring a positive attitude to the team, have a desire to succeed and make a difference in your team and community!<\/p>\n<p>Key Relationships:<\/p>\n<p>- Reports to: Project Manager<\/p>\n<p>- Works closely with: Project Manager, Project Administrator, and Field Foreman.<\/p>\n<p>- Direct Reports: Field Crews (laborers, operators, etc).<\/p>","post_title":"Project Superintendent- Utilities","post_link":"https:\/\/turnerstaffing.com\/position\/project-superintendent-utilities\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Senior","%location_country%":"United States","%location_city%":"Harmony","%location_state_id%":"MN","%location_state_name%":"Minnesota","%location_city_state%":"Harmony, MN","%education%":"Unspecified","%department%":"","%description%":"<p>The Project Superintendent is responsible for overseeing the on-site execution of projects, managing day-to-day construction activities, ensuring quality control, and maintaining strong coordination between the field team, Project Administrator, and Project Manager. The Superintendent ensures projects are completed safely, on-time, and within budget while upholding the company\u2019s mission to transform lives.<\/p>\n<p>WHAT SKILLS DO I NEED TO DO THIS JOB EXTRAORDINARILY WELL?<\/p>\n<p>Skills required:<\/p>\n<p>- 5-7 years experience in coordinating and leading plow and drill crews in construction.<\/p>\n<p>- The ability to lead crews with safety as the top priority, including leading the morning meeting with a clear path forward<\/p>\n<p>- Strong organizational skills and a keen eye for detail.<\/p>\n<p>- Excellent communication and professional skills.<\/p>\n<p>- A \u201cI will attack this problem\u201d mindset.<\/p>\n<p>- Understanding of underground cable systems- ie. fiber networks, utility grids, and construction processes.<\/p>\n<p>- Must be able to create and maintain day-to-day processes involving production reporting, ensuring schedules and budget, and maintaining equipment.<\/p>\n<p>- Work closely with the Project Manager to ensure proper staffing.<\/p>\n<p>- Must be a self-starter, bring a positive attitude to the team, have a desire to succeed and make a difference in your team and community!<\/p>\n<p>Key Relationships:<\/p>\n<p>- Reports to: Project Manager<\/p>\n<p>- Works closely with: Project Manager, Project Administrator, and Field Foreman.<\/p>\n<p>- Direct Reports: Field Crews (laborers, operators, etc).<\/p>","%category%":"Management","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/2d4cfb2043b4-project-superintendent-utilities","%breezy_id%":"2d4cfb2043b4","%breezy_friendly_id%":"2d4cfb2043b4-project-superintendent-utilities","%breezy_created_date%":"2025-03-03T16:31:15.112Z","%breezy_updated_date%":"2025-06-11T14:16:07.077Z","%_wpgmp_location_city%":"Harmony","%_wpgmp_location_state%":"MN","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Harmony, MN, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"43.5551811","%_wpgmp_metabox_longitude%":"-92.0052837","%rank_math_internal_links_processed%":"1"}},"id":2211,"infowindow_disable":false},{"source":"post","title":"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-08-13T13:32:46.766Z","%_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":"Utility Pipe Superintendent","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Utility Pipe Superintendent\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Turner Staffing Group is partnered with a grading company looking for a utility pipe superintendent!&nbsp; DescriptionAre you a motivated and&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/utility-pipe-superintendent\/\" name=\"Utility Pipe Superintendent\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Turner Staffing Group is partnered with a grading company looking for a utility pipe superintendent!&nbsp; DescriptionAre you a motivated and&hellip;","address":"Charlotte, NC, USA","location":{"lat":"35.2215548","city":"Charlotte","state":"NC","country":"United States","lng":"-80.840116","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/utility-pipe-superintendent\/","zoom":19,"extra_fields":{"post_excerpt":"Turner Staffing Group is partnered with a grading company looking for a utility pipe superintendent!&nbsp; DescriptionAre you a motivated and&hellip;","post_content":"<p>Turner Staffing Group is partnered with a grading company looking for a utility pipe superintendent!&nbsp;<\/p>\n<p><strong>Description<\/strong><br>Are you a motivated and experienced Pipe Superintendent ready to lead a pipe crew in delivering top-quality work on a variety of exciting projects? If you\u2019re professional with a passion for excellence and leadership, we want you on our team to make a difference in The Carolinas.<\/p>\n<p>Please note that the job description provided below offers a general overview of the role\u2019s responsibilities and expectations, rather than an exhaustive list of tasks.<\/p>\n<p><strong>What our team needs from you:<\/strong><\/p>\n<ul><li>Supervise operations, direct sub-contractors and maintain material inventory.<\/li><li>Operate motor vehicles and equipment necessary for completion of projects.<\/li><li>Attend training at the Academy.<\/li><li>Utilize the company's Core Values in daily duties.<\/li><li>Understand, interpret, and follow goals and directions from a foreman or superintendent.<\/li><li>Communicate professionally with everyone on site, including but not limited to supervisors, teammates, contractors, clients, and vendor partners.<\/li><li>Maintain attendance at work, including presence at work during regular work hours or another schedule as may be assigned by the foreman or superintendent. Acceptance of overtime assignments may also be required in order to meet operational needs.<\/li><\/ul>\n<p><strong>Other Duties &amp; Responsibilities:<\/strong><\/p>\n<ul><li>Perform other various assignments as assigned.<\/li><\/ul>\n<p><strong>Experience &amp; Requirements<\/strong><\/p>\n<ul><li>Experience with water, sanitary sewer and storm drainage construction specifications, techniques and installation.<\/li><li>Ability to read blueprints, plans and specifications for installation.<\/li><li>OSHA compliant with trenching, shoring, excavation and confined space entry.<\/li><li>Understand basic survey line, grade and slope.<\/li><li>A Motor Vehicle Report (MVR) will be run on anyone considered for this position.<\/li><li>Must be 18 years of age or older.<\/li><li>Must have reliable transportation.<\/li><li>Must be highly motivated and willing to learn.<\/li><li>Must be able to understand project goals and direction.<\/li><li>Must enjoy working outside in all weather conditions.<\/li><li>Must pass a pre-employment drug test, fit-for-duty physical, and background screening.<\/li><li>Must be able to communicate effectively with directors, supervisors, and teammates and be a team player.<\/li><li>Must be willing to work Monday through Friday 7 AM-5:30 PM, or another schedule as may be assigned by the foreman or superintendent, as well as Saturdays when needed.<\/li><\/ul>\n<p><strong>Essential Physical Demands of Work Environment, With or Without a Reasonable Accommodation:<\/strong><\/p>\n<ul><li>Able to walk through varied terrain.<\/li><li>Able to lift 40 lbs. (unassisted) to 80 lbs. (assisted) on a regular basis.<\/li><li>Able to lift, carry, and hold building materials, tools, and supplies.<\/li><li>Able to perform job responsibilities outdoors, in all types of weather conditions.<\/li><li>Able to maintain constant alertness and situational awareness while on the job site.<\/li><li>Able to climb on and off equipment safely while maintaining three (3) points of contact.<\/li><li>Able to use hands, arms, and feet for repetitive lifting and carrying of construction materials.<\/li><li>Able to stand\/sit for extended periods of time, as well as stoop, kneel, walk, bend, crouch, lift, and crawl as required to perform essential duties.<\/li><li>Able to communicate audibly and visually while exposed to varying levels of noise, dust and substances commonly found on construction sites.<\/li><li>Any other physical demand the assigned duties require.<\/li><\/ul>\n<p><strong>What\u2019s in it for you:<\/strong><\/p>\n<ul><li>Company Truck<\/li><li>Profit Sharing Program<\/li><li>401(k) Plan with Company Match<\/li><li>Medical Insurance<\/li><li>Voluntary Dental, Vision &amp; Life Insurances<\/li><li>Voluntary Long-Term Disability<\/li><li>Competitive Pay (based on experience)<\/li><li>Group Term Life<\/li><li>Short-Term Disability<\/li><li>Paid Vacation, Holidays, Bereavement &amp; Maternity\/Paternity Leave<\/li><li>Free Training Programs at the Academy:<ul><li>CAT Simulators<\/li><li>Classroom Training<\/li><li>Professional Development<\/li><li>Safety Training<\/li><li>First Aid Training<\/li><li>MSHA Training<\/li><\/ul><\/li><\/ul>\n<p>The company operates within a 65-mile radius from Charlotte, North Carolina. By applying for this position, you acknowledge our operation radius and understand your commute could reach up to one (1) hour. Teammates are asked to move job sites as project needs change and occasionally report to the Academy for training. All applicants to whom a conditional offer of employment is made shall undergo and pass a pre-employment screening, including drug test, background check, and a fit-for-duty exam prior to beginning work. The company is a drug-free workplace.<\/p>","post_title":"Utility Pipe Superintendent","post_link":"https:\/\/turnerstaffing.com\/position\/utility-pipe-superintendent\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"","%location_country%":"United States","%location_city%":"Charlotte","%location_state_id%":"NC","%location_state_name%":"North Carolina","%location_city_state%":"Charlotte, NC","%education%":"","%department%":"","%description%":"<p>Turner Staffing Group is partnered with a grading company looking for a utility pipe superintendent!&nbsp;<\/p>\n<p><strong>Description<\/strong><br>Are you a motivated and experienced Pipe Superintendent ready to lead a pipe crew in delivering top-quality work on a variety of exciting projects? If you\u2019re professional with a passion for excellence and leadership, we want you on our team to make a difference in The Carolinas.<\/p>\n<p>Please note that the job description provided below offers a general overview of the role\u2019s responsibilities and expectations, rather than an exhaustive list of tasks.<\/p>\n<p><strong>What our team needs from you:<\/strong><\/p>\n<ul><li>Supervise operations, direct sub-contractors and maintain material inventory.<\/li><li>Operate motor vehicles and equipment necessary for completion of projects.<\/li><li>Attend training at the Academy.<\/li><li>Utilize the company's Core Values in daily duties.<\/li><li>Understand, interpret, and follow goals and directions from a foreman or superintendent.<\/li><li>Communicate professionally with everyone on site, including but not limited to supervisors, teammates, contractors, clients, and vendor partners.<\/li><li>Maintain attendance at work, including presence at work during regular work hours or another schedule as may be assigned by the foreman or superintendent. Acceptance of overtime assignments may also be required in order to meet operational needs.<\/li><\/ul>\n<p><strong>Other Duties &amp; Responsibilities:<\/strong><\/p>\n<ul><li>Perform other various assignments as assigned.<\/li><\/ul>\n<p><strong>Experience &amp; Requirements<\/strong><\/p>\n<ul><li>Experience with water, sanitary sewer and storm drainage construction specifications, techniques and installation.<\/li><li>Ability to read blueprints, plans and specifications for installation.<\/li><li>OSHA compliant with trenching, shoring, excavation and confined space entry.<\/li><li>Understand basic survey line, grade and slope.<\/li><li>A Motor Vehicle Report (MVR) will be run on anyone considered for this position.<\/li><li>Must be 18 years of age or older.<\/li><li>Must have reliable transportation.<\/li><li>Must be highly motivated and willing to learn.<\/li><li>Must be able to understand project goals and direction.<\/li><li>Must enjoy working outside in all weather conditions.<\/li><li>Must pass a pre-employment drug test, fit-for-duty physical, and background screening.<\/li><li>Must be able to communicate effectively with directors, supervisors, and teammates and be a team player.<\/li><li>Must be willing to work Monday through Friday 7 AM-5:30 PM, or another schedule as may be assigned by the foreman or superintendent, as well as Saturdays when needed.<\/li><\/ul>\n<p><strong>Essential Physical Demands of Work Environment, With or Without a Reasonable Accommodation:<\/strong><\/p>\n<ul><li>Able to walk through varied terrain.<\/li><li>Able to lift 40 lbs. (unassisted) to 80 lbs. (assisted) on a regular basis.<\/li><li>Able to lift, carry, and hold building materials, tools, and supplies.<\/li><li>Able to perform job responsibilities outdoors, in all types of weather conditions.<\/li><li>Able to maintain constant alertness and situational awareness while on the job site.<\/li><li>Able to climb on and off equipment safely while maintaining three (3) points of contact.<\/li><li>Able to use hands, arms, and feet for repetitive lifting and carrying of construction materials.<\/li><li>Able to stand\/sit for extended periods of time, as well as stoop, kneel, walk, bend, crouch, lift, and crawl as required to perform essential duties.<\/li><li>Able to communicate audibly and visually while exposed to varying levels of noise, dust and substances commonly found on construction sites.<\/li><li>Any other physical demand the assigned duties require.<\/li><\/ul>\n<p><strong>What\u2019s in it for you:<\/strong><\/p>\n<ul><li>Company Truck<\/li><li>Profit Sharing Program<\/li><li>401(k) Plan with Company Match<\/li><li>Medical Insurance<\/li><li>Voluntary Dental, Vision &amp; Life Insurances<\/li><li>Voluntary Long-Term Disability<\/li><li>Competitive Pay (based on experience)<\/li><li>Group Term Life<\/li><li>Short-Term Disability<\/li><li>Paid Vacation, Holidays, Bereavement &amp; Maternity\/Paternity Leave<\/li><li>Free Training Programs at the Academy:<ul><li>CAT Simulators<\/li><li>Classroom Training<\/li><li>Professional Development<\/li><li>Safety Training<\/li><li>First Aid Training<\/li><li>MSHA Training<\/li><\/ul><\/li><\/ul>\n<p>The company operates within a 65-mile radius from Charlotte, North Carolina. By applying for this position, you acknowledge our operation radius and understand your commute could reach up to one (1) hour. Teammates are asked to move job sites as project needs change and occasionally report to the Academy for training. All applicants to whom a conditional offer of employment is made shall undergo and pass a pre-employment screening, including drug test, background check, and a fit-for-duty exam prior to beginning work. The company is a drug-free workplace.<\/p>","%category%":"","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/70d7e7f27703-utility-pipe-superintendent","%breezy_id%":"70d7e7f27703","%breezy_friendly_id%":"70d7e7f27703-utility-pipe-superintendent","%breezy_created_date%":"2025-02-20T19:19:21.491Z","%breezy_updated_date%":"2025-06-06T13:54:26.702Z","%_wpgmp_location_city%":"Charlotte","%_wpgmp_location_state%":"NC","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Charlotte, NC, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"35.2215548","%_wpgmp_metabox_longitude%":"-80.840116","%rank_math_internal_links_processed%":"1"}},"id":2192,"infowindow_disable":false},{"source":"post","title":"Dredge Site Safety and Health Officer","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Dredge Site Safety and Health Officer\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Job Summary: We are seeking a highly skilled and experienced Dredge Site Safety and Health Officer to oversee and ensure&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/dredge-site-safety-and-health-officer\/\" name=\"Dredge Site Safety and Health Officer\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Job Summary: We are seeking a highly skilled and experienced Dredge Site Safety and Health Officer to oversee and ensure&hellip;","address":"Guttenberg, IA, USA","location":{"lat":"42.7899897","city":"Guttenberg","state":"IA","country":"United States","lng":"-91.1029068","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/dredge-site-safety-and-health-officer\/","zoom":19,"extra_fields":{"post_excerpt":"Job Summary: We are seeking a highly skilled and experienced Dredge Site Safety and Health Officer to oversee and ensure&hellip;","post_content":"<h3><strong>Job Summary:<\/strong><\/h3>\n<p>We are seeking a highly skilled and experienced <strong>Dredge Site Safety and Health Officer<\/strong> to oversee and ensure the safety and health protocols on dredging project sites. The ideal candidate will have hands-on experience working on dredging projects and a strong understanding of the <strong>EM385<\/strong> (U.S. Army Corps of Engineers Safety and Health Manual) standards. As a key member of our team, the Safety and Health Officer will play a critical role in promoting a safe work environment, ensuring regulatory compliance, and mitigating risks on-site.<\/p>\n<h3><strong>Key Responsibilities:<\/strong><\/h3>\n<ul><li><strong>Safety Oversight<\/strong>: Monitor daily operations of dredging projects to ensure that all safety protocols are adhered to, including the handling of equipment, materials, and personnel.<\/li><li><strong>Risk Assessment<\/strong>: Conduct regular safety assessments and hazard analyses on dredge sites, identifying potential risks and implementing corrective actions to prevent accidents.<\/li><li><strong>Compliance Management<\/strong>: Ensure compliance with all relevant health, safety, and environmental regulations, particularly those outlined in the <strong>EM385 manual<\/strong>, OSHA standards, and company-specific procedures.<\/li><li><strong>Safety Training<\/strong>: Provide safety training and orientation for all site personnel, ensuring that they are familiar with emergency response plans, hazard communication, PPE (Personal Protective Equipment) requirements, and safe work practices.<\/li><li><strong>Accident Investigation<\/strong>: Lead investigations into any safety incidents or accidents, identifying root causes and recommending corrective actions to prevent future occurrences.<\/li><li><strong>Safety Reporting<\/strong>: Maintain and submit accurate safety reports, incident logs, and risk assessments to senior management and regulatory bodies as required.<\/li><li><strong>Site Inspections<\/strong>: Conduct regular inspections of dredging operations, equipment, and personnel, ensuring that safety equipment is functioning properly and that the work environment is hazard-free.<\/li><li><strong>Emergency Response Planning<\/strong>: Develop, implement, and regularly update emergency response plans for dredging activities, including spill containment, medical emergencies, and evacuation procedures.<\/li><li><strong>Stakeholder Communication<\/strong>: Collaborate with project managers, engineers, and other stakeholders to ensure safety is prioritized in all aspects of the dredging project.<\/li><\/ul>\n<h3><strong>Requirements:<\/strong><\/h3>\n<ul><li><strong>Experience<\/strong>: Minimum of 5 years of experience working on dredge project sites, with a strong understanding of dredging operations and associated risks.<\/li><li><strong>Certifications<\/strong>: OSHA 30-Hour Construction Safety Certification and\/or other relevant safety certifications.<\/li><li><strong>EM385 Knowledge<\/strong>: In-depth understanding of the <strong>EM385 Safety and Health Manual<\/strong> (U.S. Army Corps of Engineers) and its application on dredging sites.<\/li><li><strong>Training and Communication<\/strong>: Strong communication skills with the ability to deliver safety training, prepare reports, and work collaboratively with diverse teams.<\/li><li><strong>Problem Solving<\/strong>: Ability to quickly assess situations, identify potential risks, and implement practical solutions to ensure the safety of all site personnel.<\/li><li><strong>Physical Requirements<\/strong>: Must be able to work in a physically demanding environment, including exposure to outdoor elements and the dredging site atmosphere.<\/li><li><strong>First Aid &amp; CPR<\/strong>: Certification in First Aid and CPR preferred.<\/li><\/ul>\n<h3><strong>Preferred Qualifications:<\/strong><\/h3>\n<ul><li>Familiarity with additional safety management systems such as ISO 45001.<\/li><li>Previous experience in a supervisory role overseeing safety on large-scale civil or construction projects.<\/li><li>Ability to manage and work with a diverse team of employees and contractors.<\/li><\/ul>\n<h3><strong>Benefits:<\/strong><\/h3>\n<ul><li>Competitive salary and benefits package.<\/li><li>Opportunity for career advancement in a growing company.<\/li><li>Supportive work environment focused on safety and professional growth<\/li><\/ul>","post_title":"Dredge Site Safety and Health Officer","post_link":"https:\/\/turnerstaffing.com\/position\/dredge-site-safety-and-health-officer\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Senior","%location_country%":"United States","%location_city%":"Guttenberg","%location_state_id%":"IA","%location_state_name%":"Iowa","%location_city_state%":"Guttenberg, IA","%education%":"Bachelor's Degree","%department%":"","%description%":"<h3><strong>Job Summary:<\/strong><\/h3>\n<p>We are seeking a highly skilled and experienced <strong>Dredge Site Safety and Health Officer<\/strong> to oversee and ensure the safety and health protocols on dredging project sites. The ideal candidate will have hands-on experience working on dredging projects and a strong understanding of the <strong>EM385<\/strong> (U.S. Army Corps of Engineers Safety and Health Manual) standards. As a key member of our team, the Safety and Health Officer will play a critical role in promoting a safe work environment, ensuring regulatory compliance, and mitigating risks on-site.<\/p>\n<h3><strong>Key Responsibilities:<\/strong><\/h3>\n<ul><li><strong>Safety Oversight<\/strong>: Monitor daily operations of dredging projects to ensure that all safety protocols are adhered to, including the handling of equipment, materials, and personnel.<\/li><li><strong>Risk Assessment<\/strong>: Conduct regular safety assessments and hazard analyses on dredge sites, identifying potential risks and implementing corrective actions to prevent accidents.<\/li><li><strong>Compliance Management<\/strong>: Ensure compliance with all relevant health, safety, and environmental regulations, particularly those outlined in the <strong>EM385 manual<\/strong>, OSHA standards, and company-specific procedures.<\/li><li><strong>Safety Training<\/strong>: Provide safety training and orientation for all site personnel, ensuring that they are familiar with emergency response plans, hazard communication, PPE (Personal Protective Equipment) requirements, and safe work practices.<\/li><li><strong>Accident Investigation<\/strong>: Lead investigations into any safety incidents or accidents, identifying root causes and recommending corrective actions to prevent future occurrences.<\/li><li><strong>Safety Reporting<\/strong>: Maintain and submit accurate safety reports, incident logs, and risk assessments to senior management and regulatory bodies as required.<\/li><li><strong>Site Inspections<\/strong>: Conduct regular inspections of dredging operations, equipment, and personnel, ensuring that safety equipment is functioning properly and that the work environment is hazard-free.<\/li><li><strong>Emergency Response Planning<\/strong>: Develop, implement, and regularly update emergency response plans for dredging activities, including spill containment, medical emergencies, and evacuation procedures.<\/li><li><strong>Stakeholder Communication<\/strong>: Collaborate with project managers, engineers, and other stakeholders to ensure safety is prioritized in all aspects of the dredging project.<\/li><\/ul>\n<h3><strong>Requirements:<\/strong><\/h3>\n<ul><li><strong>Experience<\/strong>: Minimum of 5 years of experience working on dredge project sites, with a strong understanding of dredging operations and associated risks.<\/li><li><strong>Certifications<\/strong>: OSHA 30-Hour Construction Safety Certification and\/or other relevant safety certifications.<\/li><li><strong>EM385 Knowledge<\/strong>: In-depth understanding of the <strong>EM385 Safety and Health Manual<\/strong> (U.S. Army Corps of Engineers) and its application on dredging sites.<\/li><li><strong>Training and Communication<\/strong>: Strong communication skills with the ability to deliver safety training, prepare reports, and work collaboratively with diverse teams.<\/li><li><strong>Problem Solving<\/strong>: Ability to quickly assess situations, identify potential risks, and implement practical solutions to ensure the safety of all site personnel.<\/li><li><strong>Physical Requirements<\/strong>: Must be able to work in a physically demanding environment, including exposure to outdoor elements and the dredging site atmosphere.<\/li><li><strong>First Aid &amp; CPR<\/strong>: Certification in First Aid and CPR preferred.<\/li><\/ul>\n<h3><strong>Preferred Qualifications:<\/strong><\/h3>\n<ul><li>Familiarity with additional safety management systems such as ISO 45001.<\/li><li>Previous experience in a supervisory role overseeing safety on large-scale civil or construction projects.<\/li><li>Ability to manage and work with a diverse team of employees and contractors.<\/li><\/ul>\n<h3><strong>Benefits:<\/strong><\/h3>\n<ul><li>Competitive salary and benefits package.<\/li><li>Opportunity for career advancement in a growing company.<\/li><li>Supportive work environment focused on safety and professional growth<\/li><\/ul>","%category%":"Operations","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/4ad2cd78f6fb-dredge-site-safety-and-health-officer","%breezy_id%":"4ad2cd78f6fb","%breezy_friendly_id%":"4ad2cd78f6fb-dredge-site-safety-and-health-officer","%breezy_created_date%":"2025-02-13T19:17:54.066Z","%breezy_updated_date%":"2025-06-11T14:03:27.634Z","%_wpgmp_location_city%":"Guttenberg","%_wpgmp_location_state%":"IA","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Guttenberg, IA, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"42.7899897","%_wpgmp_metabox_longitude%":"-91.1029068","%rank_math_internal_links_processed%":"1"}},"id":2157,"infowindow_disable":false},{"source":"post","title":"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-06-20T20:06:53.628Z","%_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-06-19T18:52:52.849Z","%_wpgmp_location_city%":"Bloomington","%_wpgmp_location_state%":"IN","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Bloomington, IN, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"39.169574","%_wpgmp_metabox_longitude%":"-86.5385549","%rank_math_internal_links_processed%":"1"}},"id":2113,"infowindow_disable":false},{"source":"post","title":"Paving Superintendent","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Paving Superintendent\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Responsibilities We are looking for a hard-working, dedicated Paving Superintendent with high technical milling and paving knowledge and excellent leadership&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/paving-superintendent-2\/\" name=\"Paving Superintendent\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Responsibilities We are looking for a hard-working, dedicated Paving Superintendent with high technical milling and paving knowledge and excellent leadership&hellip;","address":"Richmond, VA, USA","location":{"lat":"37.5407246","city":"Richmond","state":"VA","country":"United States","lng":"-77.4360481","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/paving-superintendent-2\/","zoom":19,"extra_fields":{"post_excerpt":"Responsibilities We are looking for a hard-working, dedicated Paving Superintendent with high technical milling and paving knowledge and excellent leadership&hellip;","post_content":"<h2><strong>Responsibilities<\/strong><\/h2>\n<p>We are looking for a hard-working, dedicated Paving Superintendent with high technical milling and paving knowledge and excellent leadership skills. Join an elite team of professionals building exciting, innovative heavy civil projects.&nbsp;<\/p>\n<p><em>Responsibilities<\/em>:&nbsp;<\/p>\n<ul><li>Demonstrates technical proficiency in milling and paving operations.&nbsp;<\/li><li>Has a complete understanding of the plan details and specifications of assigned projects including the estimate, man-hour budget and production rates.&nbsp;&nbsp;<\/li><li>Plans and organizes work to maximize potential crew productivity. Establishes work plans and staffing plans for each phase of the project.&nbsp; Communicates performance expectations for productivity, quality, and safety to crews and monitors progress to ensure schedule and financial goals are met.&nbsp;<\/li><li>Supervises field managers for assigned projects and plans\/schedules manpower and equipment as needed. Mentors\/coaches field managers in leading their crews. Maximizes equipment utilization levels and schedules field personnel assignments.&nbsp;&nbsp;<\/li><li>Reviews job cost with Project Manager, Field Managers and implements adjustments as needed.&nbsp;&nbsp;&nbsp;<\/li><li>Coordinates and collaborates with Field Managers, other Superintendents, and the customer to implement successful project plans. Maintains professional relationships with the owner, engineer and other members of the construction team.&nbsp;&nbsp;<\/li><li>Inspects construction work as necessary to ensure quality requirements and standards are met.&nbsp;<\/li><li>Manages coordination with asphalt plants, trucking dispatchers, and MOT teams to ensure safety, profit, scheduling compliance and customer satisfaction.&nbsp;<\/li><\/ul>\n<ul><li>&nbsp;<\/li><\/ul>\n<h2><strong>Qualifications<\/strong><\/h2>\n<p>Qualifications:&nbsp;<\/p>\n<ul><li>High school diploma or equivalent (GED) required (equivalent work experience will be considered)&nbsp;<\/li><li>Bachelor\u2019s degree in Civil Engineering, Construction Management or related field preferred (continuing education in construction highly desirable)&nbsp;<\/li><li>Minimum 6 years of milling and paving experience with at least 2 years of Superintendent experience required&nbsp;<\/li><li>OSHA 30 hour certification required (those not having this credential must certify or be enrolled in a certification course within 6 months of hire\/promotion)&nbsp;<\/li><li>Valid driver\u2019s license required&nbsp;<\/li><\/ul>","post_title":"Paving Superintendent","post_link":"https:\/\/turnerstaffing.com\/position\/paving-superintendent-2\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"","%location_country%":"United States","%location_city%":"Richmond","%location_state_id%":"VA","%location_state_name%":"Virginia","%location_city_state%":"Richmond, VA","%education%":"","%department%":"","%description%":"<h2><strong>Responsibilities<\/strong><\/h2>\n<p>We are looking for a hard-working, dedicated Paving Superintendent with high technical milling and paving knowledge and excellent leadership skills. Join an elite team of professionals building exciting, innovative heavy civil projects.&nbsp;<\/p>\n<p><em>Responsibilities<\/em>:&nbsp;<\/p>\n<ul><li>Demonstrates technical proficiency in milling and paving operations.&nbsp;<\/li><li>Has a complete understanding of the plan details and specifications of assigned projects including the estimate, man-hour budget and production rates.&nbsp;&nbsp;<\/li><li>Plans and organizes work to maximize potential crew productivity. Establishes work plans and staffing plans for each phase of the project.&nbsp; Communicates performance expectations for productivity, quality, and safety to crews and monitors progress to ensure schedule and financial goals are met.&nbsp;<\/li><li>Supervises field managers for assigned projects and plans\/schedules manpower and equipment as needed. Mentors\/coaches field managers in leading their crews. Maximizes equipment utilization levels and schedules field personnel assignments.&nbsp;&nbsp;<\/li><li>Reviews job cost with Project Manager, Field Managers and implements adjustments as needed.&nbsp;&nbsp;&nbsp;<\/li><li>Coordinates and collaborates with Field Managers, other Superintendents, and the customer to implement successful project plans. Maintains professional relationships with the owner, engineer and other members of the construction team.&nbsp;&nbsp;<\/li><li>Inspects construction work as necessary to ensure quality requirements and standards are met.&nbsp;<\/li><li>Manages coordination with asphalt plants, trucking dispatchers, and MOT teams to ensure safety, profit, scheduling compliance and customer satisfaction.&nbsp;<\/li><\/ul>\n<ul><li>&nbsp;<\/li><\/ul>\n<h2><strong>Qualifications<\/strong><\/h2>\n<p>Qualifications:&nbsp;<\/p>\n<ul><li>High school diploma or equivalent (GED) required (equivalent work experience will be considered)&nbsp;<\/li><li>Bachelor\u2019s degree in Civil Engineering, Construction Management or related field preferred (continuing education in construction highly desirable)&nbsp;<\/li><li>Minimum 6 years of milling and paving experience with at least 2 years of Superintendent experience required&nbsp;<\/li><li>OSHA 30 hour certification required (those not having this credential must certify or be enrolled in a certification course within 6 months of hire\/promotion)&nbsp;<\/li><li>Valid driver\u2019s license required&nbsp;<\/li><\/ul>","%category%":"","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/8f7f240f7497-paving-superintendent","%breezy_id%":"8f7f240f7497","%breezy_friendly_id%":"8f7f240f7497-paving-superintendent","%breezy_created_date%":"2024-06-06T13:50:44.340Z","%breezy_updated_date%":"2025-05-19T15:01:38.278Z","%_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-05-19T15:01:37.181Z","%_wpgmp_location_city%":"Fairfax","%_wpgmp_location_state%":"VA","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Fairfax, VA, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"38.8459879","%_wpgmp_metabox_longitude%":"-77.3053035","%rank_math_internal_links_processed%":"1"}},"id":2111,"infowindow_disable":false},{"source":"post","title":"Electrician","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Electrician\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    We are seeking a skilled and experienced Electrician to join our team for a project-based position at a mine site&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/electrician\/\" name=\"Electrician\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"We are seeking a skilled and experienced Electrician to join our team for a project-based position at a mine site&hellip;","address":"Elko, NV, USA","location":{"lat":"40.8436459","city":"Elko","state":"NV","country":"United States","lng":"-115.7526187","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/electrician\/","zoom":19,"extra_fields":{"post_excerpt":"We are seeking a skilled and experienced Electrician to join our team for a project-based position at a mine site&hellip;","post_content":"<p>We are seeking a skilled and experienced Electrician to join our team for a project-based position at a mine site in the Elko, Nevada area. The successful candidate will be responsible for pulling cables and fiber, terminating into junction boxes and programmable logic controllers (PLCs), and ensuring the efficient and safe operation of electrical systems on-site.<\/p>\n<p><strong>Responsibilities:<\/strong><\/p>\n<ul><li>Pull and terminate cables and fiber into junction boxes and PLCs.<\/li><li>Work with a variety of voltages, ranging from 120V to 480V.<\/li><li>Perform electrical testing and troubleshoot as needed.<\/li><li>Utilize electrical meters to ensure systems are functioning correctly.<\/li><li>Operate manlifts to work at heights (on decks or in baskets) as required.<\/li><li>Follow all safety guidelines and regulations to ensure a safe work environment.<\/li><li>Work as part of a team to complete tasks in a timely and efficient manner.<\/li><\/ul>\n<p><strong>Qualifications:<\/strong><\/p>\n<ul><li>Proven experience as an electrician, specifically in industrial or mining environments.<\/li><li>Experience working with electrical systems from 120V to 480V.<\/li><li>Comfort and ability to work off a manlift at heights.<\/li><li>Proficient in using electrical meters for testing and troubleshooting.<\/li><li>Strong attention to detail with a focus on safety and quality of work.<\/li><li>Ability to work independently and as part of a team in a fast-paced environment.<\/li><li>Must be available to work Monday through Friday, 12 hours\/day, for the duration of the project (February through June).<\/li><li>Must be authorized to work in the US without work visa sponsorship<\/li><\/ul>\n<p><strong>Preferred:<\/strong><\/p>\n<ul><li>Previous mine site experience is a plus.<\/li><li>Ability to work in harsh or remote environments.<\/li><\/ul>","post_title":"Electrician","post_link":"https:\/\/turnerstaffing.com\/position\/electrician\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"","%location_country%":"United States","%location_city%":"Elko","%location_state_id%":"NV","%location_state_name%":"Nevada","%location_city_state%":"Elko, NV","%education%":"","%department%":"","%description%":"<p>We are seeking a skilled and experienced Electrician to join our team for a project-based position at a mine site in the Elko, Nevada area. The successful candidate will be responsible for pulling cables and fiber, terminating into junction boxes and programmable logic controllers (PLCs), and ensuring the efficient and safe operation of electrical systems on-site.<\/p>\n<p><strong>Responsibilities:<\/strong><\/p>\n<ul><li>Pull and terminate cables and fiber into junction boxes and PLCs.<\/li><li>Work with a variety of voltages, ranging from 120V to 480V.<\/li><li>Perform electrical testing and troubleshoot as needed.<\/li><li>Utilize electrical meters to ensure systems are functioning correctly.<\/li><li>Operate manlifts to work at heights (on decks or in baskets) as required.<\/li><li>Follow all safety guidelines and regulations to ensure a safe work environment.<\/li><li>Work as part of a team to complete tasks in a timely and efficient manner.<\/li><\/ul>\n<p><strong>Qualifications:<\/strong><\/p>\n<ul><li>Proven experience as an electrician, specifically in industrial or mining environments.<\/li><li>Experience working with electrical systems from 120V to 480V.<\/li><li>Comfort and ability to work off a manlift at heights.<\/li><li>Proficient in using electrical meters for testing and troubleshooting.<\/li><li>Strong attention to detail with a focus on safety and quality of work.<\/li><li>Ability to work independently and as part of a team in a fast-paced environment.<\/li><li>Must be available to work Monday through Friday, 12 hours\/day, for the duration of the project (February through June).<\/li><li>Must be authorized to work in the US without work visa sponsorship<\/li><\/ul>\n<p><strong>Preferred:<\/strong><\/p>\n<ul><li>Previous mine site experience is a plus.<\/li><li>Ability to work in harsh or remote environments.<\/li><\/ul>","%category%":"","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/8fecdb31d7eb-electrician","%breezy_id%":"8fecdb31d7eb","%breezy_friendly_id%":"8fecdb31d7eb-electrician","%breezy_created_date%":"2025-01-14T00:13:20.517Z","%breezy_updated_date%":"2025-07-21T16:47:53.208Z","%_wpgmp_location_city%":"Elko","%_wpgmp_location_state%":"NV","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Elko, NV, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"40.8436459","%_wpgmp_metabox_longitude%":"-115.7526187","%rank_math_internal_links_processed%":"1"}},"id":2092,"infowindow_disable":false},{"source":"post","title":"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-07-29T15:51:29.238Z","%_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":"Quarry Superintendent","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Quarry Superintendent\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Position Overview Turner Mining Group is seeking an experienced Quarry Manager to oversee daily site operations at an active quarry&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/operations-superintendent\/\" name=\"Quarry Superintendent\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Position Overview Turner Mining Group is seeking an experienced Quarry Manager to oversee daily site operations at an active quarry&hellip;","address":"Kermit, TX, USA","location":{"lat":"31.8576265","city":"Kermit","state":"TX","country":"United States","lng":"-103.0926652","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/operations-superintendent\/","zoom":19,"extra_fields":{"post_excerpt":"Position Overview Turner Mining Group is seeking an experienced Quarry Manager to oversee daily site operations at an active quarry&hellip;","post_content":"<h3><strong>Position Overview<\/strong><\/h3>\n<p>Turner Mining Group is seeking an experienced <strong>Quarry Manager<\/strong> to oversee daily site operations at an active quarry location. This individual will be responsible for managing personnel, ensuring safe and efficient production practices, maintaining equipment needs, and serving as the primary point of contact for our client\u2019s onsite management team. The Quarry Manager plays a critical role in fostering a safety-first culture, optimizing performance, and supporting the successful execution of each project.<\/p>\n<h3><strong>Key Responsibilities<\/strong><\/h3>\n<h4><strong>Operational Leadership<\/strong><\/h4>\n<ul>\n<li>\n<p>Supervise and support Foremen and crew on-site; maintain accountability for production performance and safety<\/p>\n<\/li>\n<li>\n<p>Approve daily timecards and verify accuracy<\/p>\n<\/li>\n<li>\n<p>Submit daily Field Work Orders (FWOs) for client approval<\/p>\n<\/li>\n<li>\n<p>Submit and approve purchase requisitions through the accounting system<\/p>\n<\/li>\n<li>\n<p>Execute and report survey results to the Project Manager<\/p>\n<\/li>\n<li>\n<p>Compile billable quantities and FWOs each billing cycle for pay application processing<\/p>\n<\/li>\n<li>\n<p>Build and maintain positive working relationships with the client\u2019s onsite representatives<\/p>\n<\/li>\n<li>\n<p>Monitor and ensure safe, efficient operations that minimize equipment wear and maximize productivity<\/p>\n<\/li>\n<li>\n<p>Host and escort all guests during site visits and inspections<\/p>\n<\/li>\n<li>\n<p>Communicate site material, supply, and equipment needs with appropriate team members<\/p>\n<\/li>\n<\/ul>\n<h4><strong>Safety &amp; Compliance<\/strong><\/h4>\n<ul>\n<li>\n<p>Foster and reinforce a proactive safety culture \u2014 promote \u201cAn Eye for Safety\u201d initiative across the site<\/p>\n<\/li>\n<li>\n<p>Ensure strict adherence to MSHA regulations and internal safety protocols<\/p>\n<\/li>\n<li>\n<p>Conduct and document monthly safety meetings, workplace exams, and task training<\/p>\n<\/li>\n<li>\n<p>Complete incident reports in HCSS Safety and lead root cause analyses (RCAs)<\/p>\n<\/li>\n<li>\n<p>Maintain and organize all safety documentation in compliance with TMG policy<\/p>\n<\/li>\n<li>\n<p>Address pre-operation issues and ensure timely corrective actions<\/p>\n<\/li>\n<\/ul>\n<h4><strong>Team &amp; Personnel Management<\/strong><\/h4>\n<ul>\n<li>\n<p>Submit hiring and termination requests to HR following TMG procedures<\/p>\n<\/li>\n<li>\n<p>Conduct interviews and onboarding for all onsite team members<\/p>\n<\/li>\n<li>\n<p>Evaluate performance and complete employee reviews using TMG templates<\/p>\n<\/li>\n<li>\n<p>Monitor and mentor Foremen to ensure effective leadership and execution<\/p>\n<\/li>\n<li>\n<p>Document and communicate employee performance issues to HR and Project Manager<\/p>\n<\/li>\n<li>\n<p>Maintain thorough understanding of the TMG Employee Handbook<\/p>\n<\/li>\n<\/ul>\n<h3><strong>Required Proficiencies<\/strong><\/h3>\n<ul>\n<li>\n<p>HCSS HeavyJob<\/p>\n<\/li>\n<li>\n<p>Sage Accounting System<\/p>\n<\/li>\n<li>\n<p>Microsoft Office (Excel, Word, PowerPoint)<\/p>\n<\/li>\n<li>\n<p>Email &amp; digital communication tools<\/p><\/li><\/ul><p><\/p>\n\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":"Quarry Superintendent","post_link":"https:\/\/turnerstaffing.com\/position\/operations-superintendent\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Mid Level","%location_country%":"United States","%location_city%":"Kermit","%location_state_id%":"TX","%location_state_name%":"Texas","%location_city_state%":"Kermit, TX","%education%":"Unspecified","%department%":"Operations","%description%":"<h3><strong>Position Overview<\/strong><\/h3>\n<p>Turner Mining Group is seeking an experienced <strong>Quarry Manager<\/strong> to oversee daily site operations at an active quarry location. This individual will be responsible for managing personnel, ensuring safe and efficient production practices, maintaining equipment needs, and serving as the primary point of contact for our client\u2019s onsite management team. The Quarry Manager plays a critical role in fostering a safety-first culture, optimizing performance, and supporting the successful execution of each project.<\/p>\n<h3><strong>Key Responsibilities<\/strong><\/h3>\n<h4><strong>Operational Leadership<\/strong><\/h4>\n<ul>\n<li>\n<p>Supervise and support Foremen and crew on-site; maintain accountability for production performance and safety<\/p>\n<\/li>\n<li>\n<p>Approve daily timecards and verify accuracy<\/p>\n<\/li>\n<li>\n<p>Submit daily Field Work Orders (FWOs) for client approval<\/p>\n<\/li>\n<li>\n<p>Submit and approve purchase requisitions through the accounting system<\/p>\n<\/li>\n<li>\n<p>Execute and report survey results to the Project Manager<\/p>\n<\/li>\n<li>\n<p>Compile billable quantities and FWOs each billing cycle for pay application processing<\/p>\n<\/li>\n<li>\n<p>Build and maintain positive working relationships with the client\u2019s onsite representatives<\/p>\n<\/li>\n<li>\n<p>Monitor and ensure safe, efficient operations that minimize equipment wear and maximize productivity<\/p>\n<\/li>\n<li>\n<p>Host and escort all guests during site visits and inspections<\/p>\n<\/li>\n<li>\n<p>Communicate site material, supply, and equipment needs with appropriate team members<\/p>\n<\/li>\n<\/ul>\n<h4><strong>Safety &amp; Compliance<\/strong><\/h4>\n<ul>\n<li>\n<p>Foster and reinforce a proactive safety culture \u2014 promote \u201cAn Eye for Safety\u201d initiative across the site<\/p>\n<\/li>\n<li>\n<p>Ensure strict adherence to MSHA regulations and internal safety protocols<\/p>\n<\/li>\n<li>\n<p>Conduct and document monthly safety meetings, workplace exams, and task training<\/p>\n<\/li>\n<li>\n<p>Complete incident reports in HCSS Safety and lead root cause analyses (RCAs)<\/p>\n<\/li>\n<li>\n<p>Maintain and organize all safety documentation in compliance with TMG policy<\/p>\n<\/li>\n<li>\n<p>Address pre-operation issues and ensure timely corrective actions<\/p>\n<\/li>\n<\/ul>\n<h4><strong>Team &amp; Personnel Management<\/strong><\/h4>\n<ul>\n<li>\n<p>Submit hiring and termination requests to HR following TMG procedures<\/p>\n<\/li>\n<li>\n<p>Conduct interviews and onboarding for all onsite team members<\/p>\n<\/li>\n<li>\n<p>Evaluate performance and complete employee reviews using TMG templates<\/p>\n<\/li>\n<li>\n<p>Monitor and mentor Foremen to ensure effective leadership and execution<\/p>\n<\/li>\n<li>\n<p>Document and communicate employee performance issues to HR and Project Manager<\/p>\n<\/li>\n<li>\n<p>Maintain thorough understanding of the TMG Employee Handbook<\/p>\n<\/li>\n<\/ul>\n<h3><strong>Required Proficiencies<\/strong><\/h3>\n<ul>\n<li>\n<p>HCSS HeavyJob<\/p>\n<\/li>\n<li>\n<p>Sage Accounting System<\/p>\n<\/li>\n<li>\n<p>Microsoft Office (Excel, Word, PowerPoint)<\/p>\n<\/li>\n<li>\n<p>Email &amp; digital communication tools<\/p><\/li><\/ul><p><\/p>\n\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\/e4c77db4577d-quarry-superintendent","%breezy_id%":"e4c77db4577d","%breezy_friendly_id%":"e4c77db4577d-quarry-superintendent","%breezy_created_date%":"2024-11-21T14:50:45.004Z","%breezy_updated_date%":"2025-07-10T14:26:54.328Z","%_wpgmp_location_city%":"Kermit","%_wpgmp_location_state%":"TX","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Kermit, TX, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"31.8576265","%_wpgmp_metabox_longitude%":"-103.0926652","%rank_math_internal_links_processed%":"1"}},"id":1979,"infowindow_disable":false},{"source":"post","title":"Mine Electrician","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Mine Electrician\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Job Description: In the journeyman electrician role, you will perform electrical work and inspection on wiring, fixtures, outlets, and other&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/mine-electrician\/\" name=\"Mine Electrician\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Job Description: In the journeyman electrician role, you will perform electrical work and inspection on wiring, fixtures, outlets, and other&hellip;","address":"Gabbs, NV, USA","location":{"lat":"38.8690562","city":"Gabbs","state":"NV","country":"United States","lng":"-117.9228819","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/mine-electrician\/","zoom":19,"extra_fields":{"post_excerpt":"Job Description: In the journeyman electrician role, you will perform electrical work and inspection on wiring, fixtures, outlets, and other&hellip;","post_content":"<p>Job Description:<\/p>\n<p>In the journeyman electrician role, you will perform electrical work and inspection on wiring, fixtures, outlets, and other electrical components. You will replace and repair electrical equipment and devices as required. Success in this role will be demonstrated by employing effective process controls to ensure the reliability, safety, and efficient installation and maintenance of electrical systems.<\/p>\n<p>Job Requirements:<\/p>\n<p>-Must have reasonable knowledge of electrical code and installation procedures.<\/p>\n<p>-Previous experience in 2400V; 480 \u2013 3 phase motor controls and system operation.<\/p>\n<p>-Knowledge of PLC systems and programming<\/p>\n<p>-Able to read electrical blueprints.<\/p>\n<p>-Hold a Journeymen Electrician card preferred.<\/p>\n<p>-Must have a minimum of 4 years of experience as an Industrial Electrician.<\/p>\n<p>-Troubleshoot effectively with a minimum of supervision.<\/p>\n<p>-Applicant is required to furnish their own hand tools.<\/p>\n<p>-Experience in mining is helpful.<\/p>\n<p>-Must be thoroughly familiar with all aspects of safety in the electrical field.<\/p>\n<p>-Capable of working with a minimum of supervision.<\/p>\n<p>-All work described above to be done in an efficient and workman-like manner.<\/p>\n<p>-Any knowledge of welding and fabrication is a plus but not required.<\/p>\n<p>-Applicant is responsible for the housekeeping and cleanup around their work area.<\/p>\n<p>-Additional duties are required as assigned by management.<\/p>","post_title":"Mine Electrician","post_link":"https:\/\/turnerstaffing.com\/position\/mine-electrician\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"","%location_country%":"United States","%location_city%":"Gabbs","%location_state_id%":"NV","%location_state_name%":"Nevada","%location_city_state%":"Gabbs, NV","%education%":"","%department%":"","%description%":"<p>Job Description:<\/p>\n<p>In the journeyman electrician role, you will perform electrical work and inspection on wiring, fixtures, outlets, and other electrical components. You will replace and repair electrical equipment and devices as required. Success in this role will be demonstrated by employing effective process controls to ensure the reliability, safety, and efficient installation and maintenance of electrical systems.<\/p>\n<p>Job Requirements:<\/p>\n<p>-Must have reasonable knowledge of electrical code and installation procedures.<\/p>\n<p>-Previous experience in 2400V; 480 \u2013 3 phase motor controls and system operation.<\/p>\n<p>-Knowledge of PLC systems and programming<\/p>\n<p>-Able to read electrical blueprints.<\/p>\n<p>-Hold a Journeymen Electrician card preferred.<\/p>\n<p>-Must have a minimum of 4 years of experience as an Industrial Electrician.<\/p>\n<p>-Troubleshoot effectively with a minimum of supervision.<\/p>\n<p>-Applicant is required to furnish their own hand tools.<\/p>\n<p>-Experience in mining is helpful.<\/p>\n<p>-Must be thoroughly familiar with all aspects of safety in the electrical field.<\/p>\n<p>-Capable of working with a minimum of supervision.<\/p>\n<p>-All work described above to be done in an efficient and workman-like manner.<\/p>\n<p>-Any knowledge of welding and fabrication is a plus but not required.<\/p>\n<p>-Applicant is responsible for the housekeeping and cleanup around their work area.<\/p>\n<p>-Additional duties are required as assigned by management.<\/p>","%category%":"","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/9c0b376c6bbc-mine-electrician","%breezy_id%":"9c0b376c6bbc","%breezy_friendly_id%":"9c0b376c6bbc-mine-electrician","%breezy_created_date%":"2024-11-14T16:24:57.526Z","%breezy_updated_date%":"2025-05-20T19:17:02.823Z","%_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.4482266","city":"Phoenix","state":"AZ","country":"United States","lng":"-112.0776781","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/maintenance-mechanic-hydraulics\/","zoom":19,"extra_fields":{"post_excerpt":"Position Overview We are currently hiring experienced, full-time, hourly shop and field mechanics. &nbsp;These positions diagnose, adjust, repair, fabricate, and&hellip;","post_content":"<h1>Position Overview<\/h1>\n<p>We are currently hiring experienced, full-time, hourly shop and field mechanics. &nbsp;These positions diagnose, adjust, repair, fabricate, and overhaul mobile mechanical, hydraulic, and pneumatic parts, and equipment\/vehicles. Excellent welding and fabricating experience preferred.<\/p>\n<p><\/p>\n<ul><li>For field mechanics, travel is required.<\/li><li>Mechanics&nbsp;can work a 10 days on\/4 days off, or 9 days on\/5 days off schedule.&nbsp;<\/li><\/ul>\n<p><\/p>\n<h1>Essential Functions<\/h1>\n<ul><li>Demonstrate a strong commitment to safe work practices and procedures.<\/li><li>Repair and replace damaged or worn parts.<\/li><li>Operate and inspect machines or heavy equipment to diagnose defects.<\/li><li>Diagnose faults or malfunctions to determine required repairs, using engine diagnostic equipment such as computerized test equipment and calibration devices.<\/li><li>Dismantle and reassemble heavy equipment using hoists and hand tools.<\/li><li>Clean, lubricate, and perform other routine maintenance work on equipment and vehicles.<\/li><li>Examine parts for damage or excessive wear using micrometers and gauges.<\/li><li>Schedule maintenance for industrial machines and equipment and keep equipment service records.<\/li><li>Read and understand operating manuals, blueprints, and technical drawings.<\/li><li>Weld or solder broken parts and structural members using electric or gas welders and soldering tools.<\/li><li>Fabricate needed parts or items as required.<\/li><li>Exhibit a strong work ethic with the drive and desire to learn and perform tasks efficiently.&nbsp;<\/li><li>Maintain effective and collaborative workplace relationships, treating others with dignity and respect.<\/li><\/ul>\n<p><\/p>\n<h1>Qualifications<\/h1>\n<ul><li>Must pass a pre-employment physical, drug (including the use of marijuana) and alcohol screening, Motor Vehicle Report (MVR), and additional background screening as required by regulation and\/or industry practice.&nbsp;<\/li><li>Must have a valid driver's license.&nbsp;<\/li><li>Must be willing to travel and work in remote locations, outside, and in all weather conditions (heat and cold)<\/li><li>Experience repairing and maintaining mechanical equipment.<\/li><li>Experience running, maneuvering, navigating, or driving vehicles or mechanized equipment, such as forklifts, passenger and heavy equipment, and vehicles.<\/li><li>Experience analyzing information and evaluating results to choose the best solution and solve problems.<\/li><li>Experience inspecting equipment, structures, or materials to identify the cause of errors or other problems or defects.<\/li><li>Ability to understand and carry out general instructions in standard situations.<\/li><li>Ability to make decisions with a general understanding of procedures and company policies to achieve set results and deadlines.<\/li><li>Ability to multi-task and work under aggressive deadline pressure.<\/li><li>Ability to maintain a positive outlook when challenged with difficult or unknown problems.<\/li><li>Possess good time management skills.<\/li><\/ul>","post_title":"Maintenance Mechanic","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-08-06T19:40:30.512Z","%_wpgmp_location_city%":"Phoenix","%_wpgmp_location_state%":"AZ","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Phoenix, AZ, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"33.4482266","%_wpgmp_metabox_longitude%":"-112.0776781","%rank_math_internal_links_processed%":"1"}},"id":1919,"infowindow_disable":false},{"source":"post","title":"Maintenance Mechanic &#8211; Hydraulics","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Maintenance Mechanic &#8211; Hydraulics\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Position Overview We are currently hiring experienced, full-time, hourly shop and field mechanics. &nbsp;These positions diagnose, adjust, repair, fabricate, and&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/maintenance-mechanic-hydraulics-2\/\" name=\"Maintenance Mechanic &#8211; Hydraulics\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Position Overview We are currently hiring experienced, full-time, hourly shop and field mechanics. &nbsp;These positions diagnose, adjust, repair, fabricate, and&hellip;","address":"Elko, NV, USA","location":{"lat":"40.8436459","city":"Elko","state":"NV","country":"United States","lng":"-115.7526187","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/maintenance-mechanic-hydraulics-2\/","zoom":19,"extra_fields":{"post_excerpt":"Position Overview We are currently hiring experienced, full-time, hourly shop and field mechanics. &nbsp;These positions diagnose, adjust, repair, fabricate, and&hellip;","post_content":"<h1>Position Overview<\/h1>\n<p>We are currently hiring experienced, full-time, hourly shop and field mechanics. &nbsp;These positions diagnose, adjust, repair, fabricate, and overhaul mobile mechanical, hydraulic, and pneumatic parts, and equipment\/vehicles. Excellent welding and fabricating experience preferred.<\/p>\n<p><\/p>\n<ul><li>For field mechanics, travel is required.<\/li><li>Mechanics&nbsp;can work a 10 days on\/4 days off, or 9 days on\/5 days off schedule.&nbsp;<\/li><\/ul>\n<p><\/p>\n<h1>Essential Functions<\/h1>\n<ul><li>Demonstrate a strong commitment to safe work practices and procedures.<\/li><li>Repair and replace damaged or worn parts.<\/li><li>Operate and inspect machines or heavy equipment to diagnose defects.<\/li><li>Diagnose faults or malfunctions to determine required repairs, using engine diagnostic equipment such as computerized test equipment and calibration devices.<\/li><li>Dismantle and reassemble heavy equipment using hoists and hand tools.<\/li><li>Clean, lubricate, and perform other routine maintenance work on equipment and vehicles.<\/li><li>Examine parts for damage or excessive wear using micrometers and gauges.<\/li><li>Schedule maintenance for industrial machines and equipment and keep equipment service records.<\/li><li>Read and understand operating manuals, blueprints, and technical drawings.<\/li><li>Weld or solder broken parts and structural members using electric or gas welders and soldering tools.<\/li><li>Fabricate needed parts or items as required.<\/li><li>Exhibit a strong work ethic with the drive and desire to learn and perform tasks efficiently.&nbsp;<\/li><li>Maintain effective and collaborative workplace relationships, treating others with dignity and respect.<\/li><\/ul>\n<p><\/p>\n<h1>Qualifications<\/h1>\n<ul><li>Must pass a pre-employment physical, drug (including the use of marijuana) and alcohol screening, Motor Vehicle Report (MVR), and additional background screening as required by regulation and\/or industry practice.&nbsp;<\/li><li>Must have a valid driver's license.&nbsp;<\/li><li>Must be willing to travel and work in remote locations, outside, and in all weather conditions (heat and cold)<\/li><li>Experience repairing and maintaining mechanical equipment.<\/li><li>Experience running, maneuvering, navigating, or driving vehicles or mechanized equipment, such as forklifts, passenger and heavy equipment, and vehicles.<\/li><li>Experience analyzing information and evaluating results to choose the best solution and solve problems.<\/li><li>Experience inspecting equipment, structures, or materials to identify the cause of errors or other problems or defects.<\/li><li>Ability to understand and carry out general instructions in standard situations.<\/li><li>Ability to make decisions with a general understanding of procedures and company policies to achieve set results and deadlines.<\/li><li>Ability to multi-task and work under aggressive deadline pressure.<\/li><li>Ability to maintain a positive outlook when challenged with difficult or unknown problems.<\/li><li>Possess good time management skills.<\/li><\/ul>","post_title":"Maintenance Mechanic &#8211; Hydraulics","post_link":"https:\/\/turnerstaffing.com\/position\/maintenance-mechanic-hydraulics-2\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"","%location_country%":"United States","%location_city%":"Elko","%location_state_id%":"NV","%location_state_name%":"Nevada","%location_city_state%":"Elko, NV","%education%":"","%department%":"","%description%":"<h1>Position Overview<\/h1>\n<p>We are currently hiring experienced, full-time, hourly shop and field mechanics. &nbsp;These positions diagnose, adjust, repair, fabricate, and overhaul mobile mechanical, hydraulic, and pneumatic parts, and equipment\/vehicles. Excellent welding and fabricating experience preferred.<\/p>\n<p><\/p>\n<ul><li>For field mechanics, travel is required.<\/li><li>Mechanics&nbsp;can work a 10 days on\/4 days off, or 9 days on\/5 days off schedule.&nbsp;<\/li><\/ul>\n<p><\/p>\n<h1>Essential Functions<\/h1>\n<ul><li>Demonstrate a strong commitment to safe work practices and procedures.<\/li><li>Repair and replace damaged or worn parts.<\/li><li>Operate and inspect machines or heavy equipment to diagnose defects.<\/li><li>Diagnose faults or malfunctions to determine required repairs, using engine diagnostic equipment such as computerized test equipment and calibration devices.<\/li><li>Dismantle and reassemble heavy equipment using hoists and hand tools.<\/li><li>Clean, lubricate, and perform other routine maintenance work on equipment and vehicles.<\/li><li>Examine parts for damage or excessive wear using micrometers and gauges.<\/li><li>Schedule maintenance for industrial machines and equipment and keep equipment service records.<\/li><li>Read and understand operating manuals, blueprints, and technical drawings.<\/li><li>Weld or solder broken parts and structural members using electric or gas welders and soldering tools.<\/li><li>Fabricate needed parts or items as required.<\/li><li>Exhibit a strong work ethic with the drive and desire to learn and perform tasks efficiently.&nbsp;<\/li><li>Maintain effective and collaborative workplace relationships, treating others with dignity and respect.<\/li><\/ul>\n<p><\/p>\n<h1>Qualifications<\/h1>\n<ul><li>Must pass a pre-employment physical, drug (including the use of marijuana) and alcohol screening, Motor Vehicle Report (MVR), and additional background screening as required by regulation and\/or industry practice.&nbsp;<\/li><li>Must have a valid driver's license.&nbsp;<\/li><li>Must be willing to travel and work in remote locations, outside, and in all weather conditions (heat and cold)<\/li><li>Experience repairing and maintaining mechanical equipment.<\/li><li>Experience running, maneuvering, navigating, or driving vehicles or mechanized equipment, such as forklifts, passenger and heavy equipment, and vehicles.<\/li><li>Experience analyzing information and evaluating results to choose the best solution and solve problems.<\/li><li>Experience inspecting equipment, structures, or materials to identify the cause of errors or other problems or defects.<\/li><li>Ability to understand and carry out general instructions in standard situations.<\/li><li>Ability to make decisions with a general understanding of procedures and company policies to achieve set results and deadlines.<\/li><li>Ability to multi-task and work under aggressive deadline pressure.<\/li><li>Ability to maintain a positive outlook when challenged with difficult or unknown problems.<\/li><li>Possess good time management skills.<\/li><\/ul>","%category%":"","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/763cd94c1a7b-maintenance-mechanic-hydraulics","%breezy_id%":"763cd94c1a7b","%breezy_friendly_id%":"763cd94c1a7b-maintenance-mechanic-hydraulics","%breezy_created_date%":"2024-11-01T17:38:12.191Z","%breezy_updated_date%":"2025-05-20T19:16:52.095Z","%_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-06-20T20:07:01.705Z","%_wpgmp_location_city%":"Gabbs","%_wpgmp_location_state%":"NV","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Gabbs, NV, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"38.8690562","%_wpgmp_metabox_longitude%":"-117.9228819","%rank_math_internal_links_processed%":"1"}},"id":1794,"infowindow_disable":false},{"source":"post","title":"Mobile Drill Mine Mechanic","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Mobile Drill Mine Mechanic\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Mechanic I-IV Do you want to work with the best people and equipment in the industry? Are you tired of&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/mobile-drill-mine-mechanic\/\" name=\"Mobile Drill Mine Mechanic\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Mechanic I-IV Do you want to work with the best people and equipment in the industry? Are you tired of&hellip;","address":"Elko, NV, USA","location":{"lat":"40.8436459","city":"Elko","state":"NV","country":"United States","lng":"-115.7526187","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/mobile-drill-mine-mechanic\/","zoom":19,"extra_fields":{"post_excerpt":"Mechanic I-IV Do you want to work with the best people and equipment in the industry? Are you tired of&hellip;","post_content":"<p><strong>Mechanic I-IV<\/strong><\/p>\n<p>Do you want to work with the best people and equipment in the industry? Are you tired of not having the parts and support needed to do your job? We offer clean, modern workspaces, fully stocked parts rooms, advanced repair and fabrication equipment, and knowledgeable, supportive leadership that will help you progress in your career.<\/p>\n<p>Our greatest asset is our team of hardworking professionals \u2013 especially our reliable and experienced maintenance crews. If you value integrity, an honest day\u2019s work, and professionalism, you will feel right at home.<\/p>\n<p>In addition to respect and appreciation for a job well done, we offer industry-leading equipment, monthly tooling allowance, competitive compensation, and travel per diem paired with a comprehensive Employee Benefit Program, including things like company-paid insurance premiums (where we pay 100% of the employee-only insurance premiums), 401(k) match, and paid time off.<\/p>\n<p>Position Overview<\/p>\n<p>We are currently hiring experienced, full-time, hourly shop and field mechanics. These positions diagnose, adjust, repair, fabricate, and overhaul mobile mechanical, hydraulic, and pneumatic parts, and equipment\/vehicles. Excellent welding and fabricating experience preferred.<\/p>\n<ul><li>For field mechanics, travel is required.<\/li><li>Mechanics can work a 10 days on\/4 days off, or 9 days on\/5 days off schedule.<\/li><\/ul>\n<p>Essential Functions<\/p>\n<ul><li>Demonstrate a strong commitment to safe work practices and procedures.<\/li><li>Repair and replace damaged or worn parts.<\/li><li>Operate and inspect machines or heavy equipment to diagnose defects.<\/li><li>Diagnose faults or malfunctions to determine required repairs, using engine diagnostic equipment such as computerized test equipment and calibration devices.<\/li><li>Dismantle and reassemble heavy equipment using hoists and hand tools.<\/li><li>Clean, lubricate, and perform other routine maintenance work on equipment and vehicles.<\/li><li>Examine parts for damage or excessive wear using micrometers and gauges.<\/li><li>Schedule maintenance for industrial machines and equipment and keep equipment service records.<\/li><li>Read and understand operating manuals, blueprints, and technical drawings.<\/li><li>Weld or solder broken parts and structural members using electric or gas welders and soldering tools.<\/li><li>Fabricate needed parts or items as required.<\/li><li>Exhibit a strong work ethic with the drive and desire to learn and perform tasks efficiently.<\/li><li>Maintain effective and collaborative workplace relationships, treating others with dignity and respect.<\/li><\/ul>\n<p>Qualifications<\/p>\n<ul><li>Must pass a pre-employment physical, drug (including the use of marijuana) and alcohol screening, Motor Vehicle Report (MVR), and additional background screening as required by regulation and\/or industry practice.<\/li><li>Must have a valid driver's license.<\/li><li>Must be willing to travel and work in remote locations, outside, and in all weather conditions (heat and cold)<\/li><li>Experience repairing and maintaining mechanical equipment.<\/li><li>Experience running, maneuvering, navigating, or driving vehicles or mechanized equipment, such as forklifts, passenger and heavy equipment, and vehicles.<\/li><li>Experience analyzing information and evaluating results to choose the best solution and solve problems.<\/li><li>Experience inspecting equipment, structures, or materials to identify the cause of errors or other problems or defects.<\/li><li>Ability to understand and carry out general instructions in standard situations.<\/li><li>Ability to make decisions with a general understanding of procedures and company policies to achieve set results and deadlines.<\/li><li>Ability to multi-task and work under aggressive deadline pressure.<\/li><li>Ability to maintain a positive outlook when challenged with difficult or unknown problems.<\/li><li>Possess good time management skills.<\/li><\/ul>\n<p>Typical Pay Schedule (Based upon experience)<\/p>\n<p>Mechanic I - $25\/hr.<\/p>\n<ul><li>One (1) to two (2) years\u2019 experience as a hydraulic and electrical mechanic.<\/li><li>New graduates will be considered if trained on heavy equipment with hydraulics.<\/li><\/ul>\n<p>Mechanic II - $30-$40\/hr.<\/p>\n<ul><li>Three (3) to five (5) years\u2019 experience as a hydraulic and electrical mechanic.<\/li><\/ul>\n<p>Mechanic III - $40-$55\/hr. (Pay determination based on shop position or field position)<\/p>\n<ul><li>Six (6) years\u2019 experience as a hydraulic and electrical mechanic.<\/li><li>Experienced drilling support equipment, such as mud systems, generators, and compressors preferred.<\/li><li>Ability to work independently in the field without the daily support from the Maintenance Supervisor.<\/li><\/ul>\n<p>Mechanic IV - $40-65\/hr. (Pay determination based on shop position or field position)<\/p>\n<ul><li>Six (6) plus years\u2019 experience as a hydraulic and electrical mechanic or strong knowledge with the ability to complete all aspects of the field mechanic position without support from the Maintenance Supervisor.<\/li><li>Experienced drilling support equipment, such as mud systems, generators, and compressors preferred.<\/li><\/ul>","post_title":"Mobile Drill Mine Mechanic","post_link":"https:\/\/turnerstaffing.com\/position\/mobile-drill-mine-mechanic\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"","%location_country%":"United States","%location_city%":"Elko","%location_state_id%":"NV","%location_state_name%":"Nevada","%location_city_state%":"Elko, NV","%education%":"","%department%":"","%description%":"<p><strong>Mechanic I-IV<\/strong><\/p>\n<p>Do you want to work with the best people and equipment in the industry? Are you tired of not having the parts and support needed to do your job? We offer clean, modern workspaces, fully stocked parts rooms, advanced repair and fabrication equipment, and knowledgeable, supportive leadership that will help you progress in your career.<\/p>\n<p>Our greatest asset is our team of hardworking professionals \u2013 especially our reliable and experienced maintenance crews. If you value integrity, an honest day\u2019s work, and professionalism, you will feel right at home.<\/p>\n<p>In addition to respect and appreciation for a job well done, we offer industry-leading equipment, monthly tooling allowance, competitive compensation, and travel per diem paired with a comprehensive Employee Benefit Program, including things like company-paid insurance premiums (where we pay 100% of the employee-only insurance premiums), 401(k) match, and paid time off.<\/p>\n<p>Position Overview<\/p>\n<p>We are currently hiring experienced, full-time, hourly shop and field mechanics. These positions diagnose, adjust, repair, fabricate, and overhaul mobile mechanical, hydraulic, and pneumatic parts, and equipment\/vehicles. Excellent welding and fabricating experience preferred.<\/p>\n<ul><li>For field mechanics, travel is required.<\/li><li>Mechanics can work a 10 days on\/4 days off, or 9 days on\/5 days off schedule.<\/li><\/ul>\n<p>Essential Functions<\/p>\n<ul><li>Demonstrate a strong commitment to safe work practices and procedures.<\/li><li>Repair and replace damaged or worn parts.<\/li><li>Operate and inspect machines or heavy equipment to diagnose defects.<\/li><li>Diagnose faults or malfunctions to determine required repairs, using engine diagnostic equipment such as computerized test equipment and calibration devices.<\/li><li>Dismantle and reassemble heavy equipment using hoists and hand tools.<\/li><li>Clean, lubricate, and perform other routine maintenance work on equipment and vehicles.<\/li><li>Examine parts for damage or excessive wear using micrometers and gauges.<\/li><li>Schedule maintenance for industrial machines and equipment and keep equipment service records.<\/li><li>Read and understand operating manuals, blueprints, and technical drawings.<\/li><li>Weld or solder broken parts and structural members using electric or gas welders and soldering tools.<\/li><li>Fabricate needed parts or items as required.<\/li><li>Exhibit a strong work ethic with the drive and desire to learn and perform tasks efficiently.<\/li><li>Maintain effective and collaborative workplace relationships, treating others with dignity and respect.<\/li><\/ul>\n<p>Qualifications<\/p>\n<ul><li>Must pass a pre-employment physical, drug (including the use of marijuana) and alcohol screening, Motor Vehicle Report (MVR), and additional background screening as required by regulation and\/or industry practice.<\/li><li>Must have a valid driver's license.<\/li><li>Must be willing to travel and work in remote locations, outside, and in all weather conditions (heat and cold)<\/li><li>Experience repairing and maintaining mechanical equipment.<\/li><li>Experience running, maneuvering, navigating, or driving vehicles or mechanized equipment, such as forklifts, passenger and heavy equipment, and vehicles.<\/li><li>Experience analyzing information and evaluating results to choose the best solution and solve problems.<\/li><li>Experience inspecting equipment, structures, or materials to identify the cause of errors or other problems or defects.<\/li><li>Ability to understand and carry out general instructions in standard situations.<\/li><li>Ability to make decisions with a general understanding of procedures and company policies to achieve set results and deadlines.<\/li><li>Ability to multi-task and work under aggressive deadline pressure.<\/li><li>Ability to maintain a positive outlook when challenged with difficult or unknown problems.<\/li><li>Possess good time management skills.<\/li><\/ul>\n<p>Typical Pay Schedule (Based upon experience)<\/p>\n<p>Mechanic I - $25\/hr.<\/p>\n<ul><li>One (1) to two (2) years\u2019 experience as a hydraulic and electrical mechanic.<\/li><li>New graduates will be considered if trained on heavy equipment with hydraulics.<\/li><\/ul>\n<p>Mechanic II - $30-$40\/hr.<\/p>\n<ul><li>Three (3) to five (5) years\u2019 experience as a hydraulic and electrical mechanic.<\/li><\/ul>\n<p>Mechanic III - $40-$55\/hr. (Pay determination based on shop position or field position)<\/p>\n<ul><li>Six (6) years\u2019 experience as a hydraulic and electrical mechanic.<\/li><li>Experienced drilling support equipment, such as mud systems, generators, and compressors preferred.<\/li><li>Ability to work independently in the field without the daily support from the Maintenance Supervisor.<\/li><\/ul>\n<p>Mechanic IV - $40-65\/hr. (Pay determination based on shop position or field position)<\/p>\n<ul><li>Six (6) plus years\u2019 experience as a hydraulic and electrical mechanic or strong knowledge with the ability to complete all aspects of the field mechanic position without support from the Maintenance Supervisor.<\/li><li>Experienced drilling support equipment, such as mud systems, generators, and compressors preferred.<\/li><\/ul>","%category%":"","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/d90821018e95-mobile-drill-mine-mechanic","%breezy_id%":"d90821018e95","%breezy_friendly_id%":"d90821018e95-mobile-drill-mine-mechanic","%breezy_created_date%":"2024-09-27T13:41:05.445Z","%breezy_updated_date%":"2025-05-19T15:01:30.477Z","%_wpgmp_location_city%":"Elko","%_wpgmp_location_state%":"NV","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Elko, NV, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"40.8436459","%_wpgmp_metabox_longitude%":"-115.7526187","%rank_math_internal_links_processed%":"1"}},"id":1780,"infowindow_disable":false},{"source":"post","title":"Field Service Mechanic","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Field Service Mechanic\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Mechanic I-IV Do you want to work with the best people and equipment in the industry? Are you tired of&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/field-service-mechanic\/\" name=\"Field Service Mechanic\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Mechanic I-IV Do you want to work with the best people and equipment in the industry? Are you tired of&hellip;","address":"Phoenix, AZ, USA","location":{"lat":"33.4482266","city":"Phoenix","state":"AZ","country":"United States","lng":"-112.0776781","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/field-service-mechanic\/","zoom":19,"extra_fields":{"post_excerpt":"Mechanic I-IV Do you want to work with the best people and equipment in the industry? Are you tired of&hellip;","post_content":"<p><strong>Mechanic I-IV<\/strong><\/p>\n<p>Do you want to work with the best people and equipment in the industry? Are you tired of not having the parts and support needed to do your job? We offer clean, modern workspaces, fully stocked parts rooms, advanced repair and fabrication equipment, and knowledgeable, supportive leadership that will help you progress in your career.<\/p>\n<p>Our greatest asset is our team of hardworking professionals \u2013 especially our reliable and experienced maintenance crews. If you value integrity, an honest day\u2019s work, and professionalism, you will feel right at home.<\/p>\n<p>In addition to respect and appreciation for a job well done, we offer industry-leading equipment, monthly tooling allowance, competitive compensation, and travel per diem paired with a comprehensive Employee Benefit Program, including things like company-paid insurance premiums (where we pay 100% of the employee-only insurance premiums), 401(k) match, and paid time off.  <\/p>\n<p>Position Overview<\/p>\n<p>We are currently hiring experienced, full-time, hourly shop and field mechanics.  These positions diagnose, adjust, repair, fabricate, and overhaul mobile mechanical, hydraulic, and pneumatic parts, and equipment\/vehicles. Excellent welding and fabricating experience preferred.<\/p>\n<ul>\n <li>For      field mechanics, travel is required.<\/li>\n <li>Mechanics can      work a 10 days on\/4 days off, or 9 days on\/5 days off schedule. <\/li>\n<\/ul>\n<p>Essential Functions<\/p>\n<ul>\n <li>Demonstrate      a strong commitment to safe work practices and procedures.<\/li>\n <li>Repair      and replace damaged or worn parts.<\/li>\n <li>Operate      and inspect machines or heavy equipment to diagnose defects.<\/li>\n <li>Diagnose      faults or malfunctions to determine required repairs, using engine      diagnostic equipment such as computerized test equipment and calibration      devices.<\/li>\n <li>Dismantle      and reassemble heavy equipment using hoists and hand tools.<\/li>\n <li>Clean,      lubricate, and perform other routine maintenance work on equipment and      vehicles.<\/li>\n <li>Examine      parts for damage or excessive wear using micrometers and gauges.<\/li>\n <li>Schedule      maintenance for industrial machines and equipment and keep equipment      service records.<\/li>\n <li>Read      and understand operating manuals, blueprints, and technical drawings.<\/li>\n <li>Weld      or solder broken parts and structural members using electric or gas      welders and soldering tools.<\/li>\n <li>Fabricate      needed parts or items as required.<\/li>\n <li>Exhibit      a strong work ethic with the drive and desire to learn and perform tasks      efficiently. <\/li>\n <li>Maintain      effective and collaborative workplace relationships, treating others with      dignity and respect.<\/li>\n<\/ul>\n<p>Qualifications<\/p>\n<ul>\n <li>Must      pass a pre-employment physical, drug (including the use of marijuana) and      alcohol screening, Motor Vehicle Report (MVR), and additional background      screening as required by regulation and\/or industry practice. <\/li>\n <li>Must      have a valid driver's license. <\/li>\n <li>Must      be willing to travel and work in remote locations, outside, and in all      weather conditions (heat and cold)<\/li>\n <li>Experience      repairing and maintaining mechanical equipment.<\/li>\n <li>Experience      running, maneuvering, navigating, or driving vehicles or mechanized      equipment, such as forklifts, passenger and heavy equipment, and vehicles.<\/li>\n <li>Experience      analyzing information and evaluating results to choose the best solution      and solve problems.<\/li>\n <li>Experience      inspecting equipment, structures, or materials to identify the cause of      errors or other problems or defects.<\/li>\n <li>Ability      to understand and carry out general instructions in standard situations.<\/li>\n <li>Ability      to make decisions with a general understanding of procedures and company      policies to achieve set results and deadlines.<\/li>\n <li>Ability      to multi-task and work under aggressive deadline pressure.<\/li>\n <li>Ability      to maintain a positive outlook when challenged with difficult or unknown      problems.<\/li>\n <li>Possess      good time management skills.<\/li>\n<\/ul>\n<p>Typical Pay Schedule (Based upon experience)<\/p>\n<p>Mechanic I - $25\/hr.<\/p>\n<ul>\n <li>One      (1) to two (2) years\u2019 experience as a hydraulic and electrical mechanic. <\/li>\n <li>New      graduates will be considered if trained on heavy equipment with      hydraulics. <\/li>\n<\/ul>\n<p>Mechanic II - $30-$40\/hr.<\/p>\n<ul>\n <li>Three (3) to five (5) years\u2019 experience as a      hydraulic and electrical mechanic.<\/li>\n<\/ul>\n<p>Mechanic III - $40-$55\/hr. (Pay determination based on shop position or field position)<\/p>\n<ul>\n <li>Six      (6) years\u2019 experience as a hydraulic and electrical mechanic. <\/li>\n <li>Experienced      drilling support equipment, such as mud systems, generators, and      compressors preferred.<\/li>\n <li>Ability      to work independently in the field without the daily support from the      Maintenance Supervisor.<\/li>\n<\/ul>\n<p>Mechanic IV - $40-65\/hr. (Pay determination based on shop position or field position)<\/p>\n<ul>\n <li>Six      (6) plus years\u2019 experience as a hydraulic and electrical mechanic or      strong knowledge with the ability to complete all aspects of the field      mechanic position without support from the Maintenance Supervisor. <\/li>\n <li>Experienced      drilling support equipment, such as mud systems, generators, and      compressors preferred.<\/li>\n<\/ul>","post_title":"Field Service Mechanic","post_link":"https:\/\/turnerstaffing.com\/position\/field-service-mechanic\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"","%location_country%":"United States","%location_city%":"Phoenix","%location_state_id%":"AZ","%location_state_name%":"Arizona","%location_city_state%":"Phoenix, AZ","%education%":"","%department%":"","%description%":"<p><strong>Mechanic I-IV<\/strong><\/p>\n<p>Do you want to work with the best people and equipment in the industry? Are you tired of not having the parts and support needed to do your job? We offer clean, modern workspaces, fully stocked parts rooms, advanced repair and fabrication equipment, and knowledgeable, supportive leadership that will help you progress in your career.<\/p>\n<p>Our greatest asset is our team of hardworking professionals \u2013 especially our reliable and experienced maintenance crews. If you value integrity, an honest day\u2019s work, and professionalism, you will feel right at home.<\/p>\n<p>In addition to respect and appreciation for a job well done, we offer industry-leading equipment, monthly tooling allowance, competitive compensation, and travel per diem paired with a comprehensive Employee Benefit Program, including things like company-paid insurance premiums (where we pay 100% of the employee-only insurance premiums), 401(k) match, and paid time off.  <\/p>\n<p>Position Overview<\/p>\n<p>We are currently hiring experienced, full-time, hourly shop and field mechanics.  These positions diagnose, adjust, repair, fabricate, and overhaul mobile mechanical, hydraulic, and pneumatic parts, and equipment\/vehicles. Excellent welding and fabricating experience preferred.<\/p>\n<ul>\n <li>For      field mechanics, travel is required.<\/li>\n <li>Mechanics can      work a 10 days on\/4 days off, or 9 days on\/5 days off schedule. <\/li>\n<\/ul>\n<p>Essential Functions<\/p>\n<ul>\n <li>Demonstrate      a strong commitment to safe work practices and procedures.<\/li>\n <li>Repair      and replace damaged or worn parts.<\/li>\n <li>Operate      and inspect machines or heavy equipment to diagnose defects.<\/li>\n <li>Diagnose      faults or malfunctions to determine required repairs, using engine      diagnostic equipment such as computerized test equipment and calibration      devices.<\/li>\n <li>Dismantle      and reassemble heavy equipment using hoists and hand tools.<\/li>\n <li>Clean,      lubricate, and perform other routine maintenance work on equipment and      vehicles.<\/li>\n <li>Examine      parts for damage or excessive wear using micrometers and gauges.<\/li>\n <li>Schedule      maintenance for industrial machines and equipment and keep equipment      service records.<\/li>\n <li>Read      and understand operating manuals, blueprints, and technical drawings.<\/li>\n <li>Weld      or solder broken parts and structural members using electric or gas      welders and soldering tools.<\/li>\n <li>Fabricate      needed parts or items as required.<\/li>\n <li>Exhibit      a strong work ethic with the drive and desire to learn and perform tasks      efficiently. <\/li>\n <li>Maintain      effective and collaborative workplace relationships, treating others with      dignity and respect.<\/li>\n<\/ul>\n<p>Qualifications<\/p>\n<ul>\n <li>Must      pass a pre-employment physical, drug (including the use of marijuana) and      alcohol screening, Motor Vehicle Report (MVR), and additional background      screening as required by regulation and\/or industry practice. <\/li>\n <li>Must      have a valid driver's license. <\/li>\n <li>Must      be willing to travel and work in remote locations, outside, and in all      weather conditions (heat and cold)<\/li>\n <li>Experience      repairing and maintaining mechanical equipment.<\/li>\n <li>Experience      running, maneuvering, navigating, or driving vehicles or mechanized      equipment, such as forklifts, passenger and heavy equipment, and vehicles.<\/li>\n <li>Experience      analyzing information and evaluating results to choose the best solution      and solve problems.<\/li>\n <li>Experience      inspecting equipment, structures, or materials to identify the cause of      errors or other problems or defects.<\/li>\n <li>Ability      to understand and carry out general instructions in standard situations.<\/li>\n <li>Ability      to make decisions with a general understanding of procedures and company      policies to achieve set results and deadlines.<\/li>\n <li>Ability      to multi-task and work under aggressive deadline pressure.<\/li>\n <li>Ability      to maintain a positive outlook when challenged with difficult or unknown      problems.<\/li>\n <li>Possess      good time management skills.<\/li>\n<\/ul>\n<p>Typical Pay Schedule (Based upon experience)<\/p>\n<p>Mechanic I - $25\/hr.<\/p>\n<ul>\n <li>One      (1) to two (2) years\u2019 experience as a hydraulic and electrical mechanic. <\/li>\n <li>New      graduates will be considered if trained on heavy equipment with      hydraulics. <\/li>\n<\/ul>\n<p>Mechanic II - $30-$40\/hr.<\/p>\n<ul>\n <li>Three (3) to five (5) years\u2019 experience as a      hydraulic and electrical mechanic.<\/li>\n<\/ul>\n<p>Mechanic III - $40-$55\/hr. (Pay determination based on shop position or field position)<\/p>\n<ul>\n <li>Six      (6) years\u2019 experience as a hydraulic and electrical mechanic. <\/li>\n <li>Experienced      drilling support equipment, such as mud systems, generators, and      compressors preferred.<\/li>\n <li>Ability      to work independently in the field without the daily support from the      Maintenance Supervisor.<\/li>\n<\/ul>\n<p>Mechanic IV - $40-65\/hr. (Pay determination based on shop position or field position)<\/p>\n<ul>\n <li>Six      (6) plus years\u2019 experience as a hydraulic and electrical mechanic or      strong knowledge with the ability to complete all aspects of the field      mechanic position without support from the Maintenance Supervisor. <\/li>\n <li>Experienced      drilling support equipment, such as mud systems, generators, and      compressors preferred.<\/li>\n<\/ul>","%category%":"","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/dc2c4e8acbff-field-service-mechanic","%breezy_id%":"dc2c4e8acbff","%breezy_friendly_id%":"dc2c4e8acbff-field-service-mechanic","%breezy_created_date%":"2024-09-16T18:59:19.280Z","%breezy_updated_date%":"2025-07-21T16:47:57.539Z","%_wpgmp_location_city%":"Phoenix","%_wpgmp_location_state%":"AZ","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Phoenix, AZ, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"33.4482266","%_wpgmp_metabox_longitude%":"-112.0776781","%rank_math_internal_links_processed%":"1"}},"id":1735,"infowindow_disable":false},{"source":"post","title":"Field Service Technician &#8211; Mining","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Field Service Technician &#8211; Mining\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Turner Staffing Group &#8211; Heavy Equipment Mechanic Turner Staffing Group is committed to changing the way mining companies do business.&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/field-service-technician-mining-2\/\" name=\"Field Service Technician &#8211; Mining\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Turner Staffing Group &#8211; Heavy Equipment Mechanic Turner Staffing Group is committed to changing the way mining companies do business.&hellip;","address":"Phoenix, AZ, USA","location":{"lat":"33.4482266","city":"Phoenix","state":"AZ","country":"United States","lng":"-112.0776781","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/field-service-technician-mining-2\/","zoom":19,"extra_fields":{"post_excerpt":"Turner Staffing Group &#8211; Heavy Equipment Mechanic Turner Staffing Group is committed to changing the way mining companies do business.&hellip;","post_content":"<p><strong><u>Turner Staffing Group - Heavy Equipment Mechanic<\/u><\/strong><br><\/p>\n<p style=\"color:#000000\"><span style=\"color:#333333\">Turner Staffing Group is committed to changing the way mining companies do business. We develop our people. We partner with our clients. We believe in win, win, win.<\/span><\/p>\n<p>We are looking for a dynamic and talented professional to fill a Heavy Equipment Mechanic role at our fast-growing, forward thinking mining services company.&nbsp;This is an opportunity to work as part of the operations team in a safe, productive, and fun environment.<span style=\"color:#333333\"><\/span><\/p>\n\n\n\n\n\n\n<p><strong>Position Description<\/strong><\/p>\n<p>The&nbsp;Mechanic is a full-time, hourly status classification.&nbsp; This position diagnoses, adjusts, repairs, fabricates, and\/or overhauls mobile mechanical, hydraulic, and pneumatic parts, equipment\/vehicles. Prefer candidates with excellent welding and fabricating experience. Travel is required.<span style=\"color:#333333\"><\/span><\/p>\n\n<p><strong>Essential Skills &amp; Knowledge<\/strong><\/p>\n<ul><li>Repair and replace damaged or worn parts<\/li><li>Operate and inspect machines or heavy equipment in order to diagnose defects<\/li><li>Diagnose faults or malfunctions to determine required repairs, using engine diagnostic equipment such as computerized test equipment and calibration devices<\/li><li>Dismantle and reassemble heavy equipment using hoists and hand tools<\/li><li>Clean, lubricate, and perform other routine maintenance work on equipment and vehicles<\/li><li>Examine parts for damage or excessive wear using micrometers and gauges<\/li><li>Schedule maintenance for industrial machines and equipment and keep equipment service records<\/li><li>Read and understand operating manuals, blueprints, and technical drawings<\/li><li>Weld or solder broken parts and structural members using electric or gas welders and soldering tools<\/li><li>Fabricate needed parts or items as required<\/li><li>Performs other related duties as required and assigned<\/li><\/ul>\n\n<p><strong>Benefits<\/strong><\/p>\n<p style=\"color:#000000\"><span style=\"color:#333333\">Turner Staffing Group&nbsp;offers a competitive salary, an excellent work culture, career advancement opportunities. Our team offers a benefits program which includes Medical, Dental, Vision, Life, and a 401k with company match. We believe in a work life balance and established paid time off for major holidays.<\/span><span style=\"color:#333333\"><\/span><\/p>\n\n<p>At Turner Staffing Group, we encourage and celebrate an inclusive environment for all employees and are proud to be an equal opportunity workplace and affirmative action employer.<\/p>","post_title":"Field Service Technician &#8211; Mining","post_link":"https:\/\/turnerstaffing.com\/position\/field-service-technician-mining-2\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Associate","%location_country%":"United States","%location_city%":"Phoenix","%location_state_id%":"AZ","%location_state_name%":"Arizona","%location_city_state%":"Phoenix, AZ","%education%":"Unspecified","%department%":"Operations","%description%":"<p><strong><u>Turner Staffing Group - Heavy Equipment Mechanic<\/u><\/strong><br><\/p>\n<p style=\"color:#000000;\"><span style=\"color:#333333;\">Turner Staffing Group is committed to changing the way mining companies do business. We develop our people. We partner with our clients. We believe in win, win, win.<\/span><\/p>\n<p>We are looking for a dynamic and talented professional to fill a Heavy Equipment Mechanic role at our fast-growing, forward thinking mining services company.&nbsp;This is an opportunity to work as part of the operations team in a safe, productive, and fun environment.<span style=\"color:#333333;\"><\/span><\/p>\n\n\n\n\n\n\n<p><strong>Position Description<\/strong><\/p>\n<p>The&nbsp;Mechanic is a full-time, hourly status classification.&nbsp; This position diagnoses, adjusts, repairs, fabricates, and\/or overhauls mobile mechanical, hydraulic, and pneumatic parts, equipment\/vehicles. Prefer candidates with excellent welding and fabricating experience. Travel is required.<span style=\"color:#333333;\"><\/span><\/p>\n\n<p><strong>Essential Skills &amp; Knowledge<\/strong><\/p>\n<ul><li>Repair and replace damaged or worn parts<\/li><li>Operate and inspect machines or heavy equipment in order to diagnose defects<\/li><li>Diagnose faults or malfunctions to determine required repairs, using engine diagnostic equipment such as computerized test equipment and calibration devices<\/li><li>Dismantle and reassemble heavy equipment using hoists and hand tools<\/li><li>Clean, lubricate, and perform other routine maintenance work on equipment and vehicles<\/li><li>Examine parts for damage or excessive wear using micrometers and gauges<\/li><li>Schedule maintenance for industrial machines and equipment and keep equipment service records<\/li><li>Read and understand operating manuals, blueprints, and technical drawings<\/li><li>Weld or solder broken parts and structural members using electric or gas welders and soldering tools<\/li><li>Fabricate needed parts or items as required<\/li><li>Performs other related duties as required and assigned<\/li><\/ul>\n\n<p><strong>Benefits<\/strong><\/p>\n<p style=\"color:#000000;\"><span style=\"color:#333333;\">Turner Staffing Group&nbsp;offers a competitive salary, an excellent work culture, career advancement opportunities. Our team offers a benefits program which includes Medical, Dental, Vision, Life, and a 401k with company match. We believe in a work life balance and established paid time off for major holidays.<\/span><span style=\"color:#333333;\"><\/span><\/p>\n\n<p>At Turner Staffing Group, we encourage and celebrate an inclusive environment for all employees and are proud to be an equal opportunity workplace and affirmative action employer.<\/p>","%category%":"Operations","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/066af176e0a7-field-service-technician-mining","%breezy_id%":"066af176e0a7","%breezy_friendly_id%":"066af176e0a7-field-service-technician-mining","%breezy_created_date%":"2024-08-27T16:00:18.711Z","%breezy_updated_date%":"2025-07-21T16:47:59.381Z","%_wpgmp_location_city%":"Phoenix","%_wpgmp_location_state%":"AZ","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Phoenix, AZ, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"33.4482266","%_wpgmp_metabox_longitude%":"-112.0776781","%rank_math_internal_links_processed%":"1"}},"id":1698,"infowindow_disable":false},{"source":"post","title":"Field Service Technician &#8211; Mining","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Field Service Technician &#8211; Mining\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Turner Staffing Group &#8211; Heavy Equipment Mechanic Turner Staffing Group is committed to changing the way mining companies do business.&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/field-service-technician-mining\/\" name=\"Field Service Technician &#8211; Mining\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Turner Staffing Group &#8211; Heavy Equipment Mechanic Turner Staffing Group is committed to changing the way mining companies do business.&hellip;","address":"Elko, NV, USA","location":{"lat":"40.8436459","city":"Elko","state":"NV","country":"United States","lng":"-115.7526187","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/field-service-technician-mining\/","zoom":19,"extra_fields":{"post_excerpt":"Turner Staffing Group &#8211; Heavy Equipment Mechanic Turner Staffing Group is committed to changing the way mining companies do business.&hellip;","post_content":"<p><strong><u>Turner Staffing Group - Heavy Equipment Mechanic<\/u><\/strong><br><\/p>\n<p style=\"color:#000000\"><span style=\"color:#333333\">Turner Staffing Group is committed to changing the way mining companies do business. We develop our people. We partner with our clients. We believe in win, win, win.<\/span><\/p>\n<p>We are looking for a dynamic and talented professional to fill a Heavy Equipment Mechanic role at our fast-growing, forward thinking mining services company.<\/p>\n<p style=\"color:#000000\"><span style=\"color:#333333\">Turner Staffing Group is seeking an energetic professional who can leverage their Heavy Equipment knowledge to expand upon our fast-growing business, creating best practices for systems and scalable business processes to ensure profitable operations. <\/span><\/p>\n<p><\/p>\n<p>This person will function as a Heavy Equipment Mechanic, willingness to do, learn, perform and improve any maintenance task. <\/p>\n<p><\/p>\n<p>Tasks will be defined and evolve in all areas of mining operations to ensure preventative maintenance is practiced, repairs, equipment runs in the area of responsibility. You will report to and work with the Project Superintendent to develop heavy equipment procedures that will ensure safe operations. <\/p>\n<p><\/p>\n<p>This is an opportunity to work as part of the operations team in a safe, productive, and fun environment.<\/p>\n<p style=\"color:#000000\"><span style=\"color:#333333\"> <\/span><\/p>\n<p><strong>Position Description<\/strong><\/p>\n<p>The Mechanic is a full-time, hourly status classification.&nbsp; This position diagnoses, adjusts, repairs, fabricates, and\/or overhauls mobile mechanical, hydraulic, and pneumatic parts, equipment\/vehicles. Prefer candidates with excellent welding and fabricating experience. Travel is required.<strong><br><\/strong><br><\/p>\n<p style=\"color:#000000\"><span style=\"color:#333333\"> <\/span><\/p>\n<p><strong>Essential Skills &amp; Knowledge<\/strong><\/p>\n<ul><li>Repair and replace damaged or worn parts<\/li><li>Operate and inspect machines or heavy equipment in order to diagnose defects<\/li><li>Diagnose faults or malfunctions to determine required repairs, using engine diagnostic equipment such as computerized test equipment and calibration devices<\/li><li>Dismantle and reassemble heavy equipment using hoists and hand tools<\/li><li>Clean, lubricate, and perform other routine maintenance work on equipment and vehicles<\/li><li>Examine parts for damage or excessive wear using micrometers and gauges<\/li><li>Schedule maintenance for industrial machines and equipment and keep equipment service records<\/li><li>Read and understand operating manuals, blueprints, and technical drawings<\/li><li>Weld or solder broken parts and structural members using electric or gas welders and soldering tools<\/li><li>Fabricate needed parts or items as required<\/li><li>Performs other related duties as required and assigned<\/li><\/ul>\n<p style=\"color:#000000\"><br><\/p>\n<p style=\"color:#000000\"><span style=\"color:#333333\"> <\/span><\/p>\n<p><strong>Benefits<\/strong><\/p>\n<p style=\"color:#000000\"><span style=\"color:#333333\">Turner Staffing Group&nbsp;offers a competitive salary, an excellent work culture, career advancement opportunities. Our team offers a benefits program which includes Medical, Dental, Vision, Life, and a 401k with company match. We believe in a work life balance and established paid time off for major holidays.<\/span><\/p>\n<p style=\"color:#000000\"><span style=\"color:#333333\"> <\/span><\/p>\n<p>At Turner Staffing Group, we encourage and celebrate an inclusive environment for all employees and are proud to be an equal opportunity workplace and affirmative action employer.<\/p>","post_title":"Field Service Technician &#8211; Mining","post_link":"https:\/\/turnerstaffing.com\/position\/field-service-technician-mining\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"","%location_country%":"United States","%location_city%":"Elko","%location_state_id%":"NV","%location_state_name%":"Nevada","%location_city_state%":"Elko, NV","%education%":"","%department%":"Equipment","%description%":"<p><strong><u>Turner Staffing Group - Heavy Equipment Mechanic<\/u><\/strong><br><\/p>\n<p style=\"color:#000000;\"><span style=\"color:#333333;\">Turner Staffing Group is committed to changing the way mining companies do business. We develop our people. We partner with our clients. We believe in win, win, win.<\/span><\/p>\n<p>We are looking for a dynamic and talented professional to fill a Heavy Equipment Mechanic role at our fast-growing, forward thinking mining services company.<\/p>\n<p style=\"color:#000000;\"><span style=\"color:#333333;\">Turner Staffing Group is seeking an energetic professional who can leverage their Heavy Equipment knowledge to expand upon our fast-growing business, creating best practices for systems and scalable business processes to ensure profitable operations. <\/span><\/p>\n<p><\/p>\n<p>This person will function as a Heavy Equipment Mechanic, willingness to do, learn, perform and improve any maintenance task. <\/p>\n<p><\/p>\n<p>Tasks will be defined and evolve in all areas of mining operations to ensure preventative maintenance is practiced, repairs, equipment runs in the area of responsibility. You will report to and work with the Project Superintendent to develop heavy equipment procedures that will ensure safe operations. <\/p>\n<p><\/p>\n<p>This is an opportunity to work as part of the operations team in a safe, productive, and fun environment.<\/p>\n<p style=\"color:#000000;\"><span style=\"color:#333333;\"> <\/span><\/p>\n<p><strong>Position Description<\/strong><\/p>\n<p>The Mechanic is a full-time, hourly status classification.&nbsp; This position diagnoses, adjusts, repairs, fabricates, and\/or overhauls mobile mechanical, hydraulic, and pneumatic parts, equipment\/vehicles. Prefer candidates with excellent welding and fabricating experience. Travel is required.<strong><br><\/strong><br><\/p>\n<p style=\"color:#000000;\"><span style=\"color:#333333;\"> <\/span><\/p>\n<p><strong>Essential Skills &amp; Knowledge<\/strong><\/p>\n<ul><li>Repair and replace damaged or worn parts<\/li><li>Operate and inspect machines or heavy equipment in order to diagnose defects<\/li><li>Diagnose faults or malfunctions to determine required repairs, using engine diagnostic equipment such as computerized test equipment and calibration devices<\/li><li>Dismantle and reassemble heavy equipment using hoists and hand tools<\/li><li>Clean, lubricate, and perform other routine maintenance work on equipment and vehicles<\/li><li>Examine parts for damage or excessive wear using micrometers and gauges<\/li><li>Schedule maintenance for industrial machines and equipment and keep equipment service records<\/li><li>Read and understand operating manuals, blueprints, and technical drawings<\/li><li>Weld or solder broken parts and structural members using electric or gas welders and soldering tools<\/li><li>Fabricate needed parts or items as required<\/li><li>Performs other related duties as required and assigned<\/li><\/ul>\n<p style=\"color:#000000;\"><br><\/p>\n<p style=\"color:#000000;\"><span style=\"color:#333333;\"> <\/span><\/p>\n<p><strong>Benefits<\/strong><\/p>\n<p style=\"color:#000000;\"><span style=\"color:#333333;\">Turner Staffing Group&nbsp;offers a competitive salary, an excellent work culture, career advancement opportunities. Our team offers a benefits program which includes Medical, Dental, Vision, Life, and a 401k with company match. We believe in a work life balance and established paid time off for major holidays.<\/span><\/p>\n<p style=\"color:#000000;\"><span style=\"color:#333333;\"> <\/span><\/p>\n<p>At Turner Staffing Group, we encourage and celebrate an inclusive environment for all employees and are proud to be an equal opportunity workplace and affirmative action employer.<\/p>","%category%":"Other","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/f3dfde960edc-field-service-technician-mining","%breezy_id%":"f3dfde960edc","%breezy_friendly_id%":"f3dfde960edc-field-service-technician-mining","%breezy_created_date%":"2023-04-20T16:57:18.967Z","%breezy_updated_date%":"2025-07-21T16:48:00.321Z","%_wpgmp_location_city%":"Elko","%_wpgmp_location_state%":"NV","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Elko, NV, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"40.8436459","%_wpgmp_metabox_longitude%":"-115.7526187","%rank_math_internal_links_processed%":"1"}},"id":1695,"infowindow_disable":false},{"source":"post","title":"Mining Maintenance Mechanic","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Mining Maintenance Mechanic\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Maintenance Mechanic&nbsp; Job Description: Repairs and maintains plant equipment as assigned, including electric and gas welding, hydraulics, rigging, pipe fitting,pumps,&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/mining-maintenance-mechanic\/\" name=\"Mining Maintenance Mechanic\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Maintenance Mechanic&nbsp; Job Description: Repairs and maintains plant equipment as assigned, including electric and gas welding, hydraulics, rigging, pipe fitting,pumps,&hellip;","address":"Ely, NV, USA","location":{"lat":"39.2533328","city":"Ely","state":"NV","country":"United States","lng":"-114.874248","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/mining-maintenance-mechanic\/","zoom":19,"extra_fields":{"post_excerpt":"Maintenance Mechanic&nbsp; Job Description: Repairs and maintains plant equipment as assigned, including electric and gas welding, hydraulics, rigging, pipe fitting,pumps,&hellip;","post_content":"<p>Maintenance Mechanic&nbsp;<\/p>\n<p>Job Description:<\/p>\n<p>Repairs and maintains plant equipment as assigned, including electric and gas welding, hydraulics, rigging, pipe fitting,<br>pumps, air compressors, vacuum pumps, bearings and seals, power transmissions, gear boxes, equipment settings and<br>alignment.<\/p>\n<p>Job Requirements:<\/p>\n<p>Must have a minimum set of hand tools as specified by the Company. Previous experience must include a minimum of four<br>years as a millwright.<br>Job includes but is not limited to: repair of conveyor belts, bucket elevators, crushers, ball mills, screens, pumps, etc.<br>Experience in industrial construction and\/or repair may count. Must be able to read and understand blueprints and equipment<br>instructions. Must be able to weld with enough proficiency to pass a Company welding test in both electrical arc and<br>oxygen\/acetylene welding and understand the safe handling of welding equipment. Must be able to determine what type of<br>rod to use on different types of steel and cast iron. Must be thoroughly familiar with all aspects of safety in the maintenance<br>field. Must be capable of working with a minimum of supervision. Must be able to work all shifts. A written test will be<br>given as part of the company\u2019s evaluation of aptitude for the job. All work described above to be done in an efficient and<br>workman-like manner. This position is subject to duties as assigned.<br>This position is subject to shift work.<br>Additional :<br>Job requires a thorough knowledge of the load bearing capabilities of the equipment used as well as an understanding of<br>blueprints and technical instructions. Primary purpose of installing, maintaining, upgrading, and fabricating machinery and<br>equipment according to layout plans, blueprints, and other drawings in industrial establishment.<br>Typical duties include:<br>\uf0b7Read blueprints and schematic drawings to determine work procedures. Dismantle machinery or equipment, using hammers,<br>wrenches, crowbars, and other hand tools.<br>\uf0b7Moves machinery and equipment, using hoists, dollies, rollers, and trucks.<br>\uf0b7Assembles and installs equipment, such as shafting, conveyors, and tram rails, using hand tools and power tools.<br>\uf0b7Constructs foundation for machines, using hand tools and building materials, such as wood cement, and steel.<br>\uf0b7Align machines and equipment, using hoists, jacks, hand tools, squares, rules, micrometers, lasers, and plumb bobs.<br>\uf0b7Assembles machinery and bolts, welds, rivets, or otherwise fastens them to foundation or other structures, using hand tools<br>and power tools.<br>\uf0b7May operate engine lathe or milling machine to grind, file, and turn machine parts to dimensional specifications.<br>\uf0b7Required repair and lubricate machinery and equipment.<br>\uf0b7Selects cables, ropes, chains, pulleys, winches, blocks, and sheaves, according to weight and size of load to be moved.<br>\uf0b7Attaches load with grappling devices, such as loops, wires, ropes, and chains, to crane hook.<br>\uf0b7Sets up, braces, and rigs hoisting equipment, using hand tools and power wrenches.<br>\uf0b7May direct workers engaged in hoisting of machinery and equipment.<\/p>","post_title":"Mining Maintenance Mechanic","post_link":"https:\/\/turnerstaffing.com\/position\/mining-maintenance-mechanic\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"","%location_country%":"United States","%location_city%":"Ely","%location_state_id%":"NV","%location_state_name%":"Nevada","%location_city_state%":"Ely, NV","%education%":"","%department%":"","%description%":"<p>Maintenance Mechanic&nbsp;<\/p>\n<p>Job Description:<\/p>\n<p>Repairs and maintains plant equipment as assigned, including electric and gas welding, hydraulics, rigging, pipe fitting,<br>pumps, air compressors, vacuum pumps, bearings and seals, power transmissions, gear boxes, equipment settings and<br>alignment.<\/p>\n<p>Job Requirements:<\/p>\n<p>Must have a minimum set of hand tools as specified by the Company. Previous experience must include a minimum of four<br>years as a millwright.<br>Job includes but is not limited to: repair of conveyor belts, bucket elevators, crushers, ball mills, screens, pumps, etc.<br>Experience in industrial construction and\/or repair may count. Must be able to read and understand blueprints and equipment<br>instructions. Must be able to weld with enough proficiency to pass a Company welding test in both electrical arc and<br>oxygen\/acetylene welding and understand the safe handling of welding equipment. Must be able to determine what type of<br>rod to use on different types of steel and cast iron. Must be thoroughly familiar with all aspects of safety in the maintenance<br>field. Must be capable of working with a minimum of supervision. Must be able to work all shifts. A written test will be<br>given as part of the company\u2019s evaluation of aptitude for the job. All work described above to be done in an efficient and<br>workman-like manner. This position is subject to duties as assigned.<br>This position is subject to shift work.<br>Additional :<br>Job requires a thorough knowledge of the load bearing capabilities of the equipment used as well as an understanding of<br>blueprints and technical instructions. Primary purpose of installing, maintaining, upgrading, and fabricating machinery and<br>equipment according to layout plans, blueprints, and other drawings in industrial establishment.<br>Typical duties include:<br>\uf0b7Read blueprints and schematic drawings to determine work procedures. Dismantle machinery or equipment, using hammers,<br>wrenches, crowbars, and other hand tools.<br>\uf0b7Moves machinery and equipment, using hoists, dollies, rollers, and trucks.<br>\uf0b7Assembles and installs equipment, such as shafting, conveyors, and tram rails, using hand tools and power tools.<br>\uf0b7Constructs foundation for machines, using hand tools and building materials, such as wood cement, and steel.<br>\uf0b7Align machines and equipment, using hoists, jacks, hand tools, squares, rules, micrometers, lasers, and plumb bobs.<br>\uf0b7Assembles machinery and bolts, welds, rivets, or otherwise fastens them to foundation or other structures, using hand tools<br>and power tools.<br>\uf0b7May operate engine lathe or milling machine to grind, file, and turn machine parts to dimensional specifications.<br>\uf0b7Required repair and lubricate machinery and equipment.<br>\uf0b7Selects cables, ropes, chains, pulleys, winches, blocks, and sheaves, according to weight and size of load to be moved.<br>\uf0b7Attaches load with grappling devices, such as loops, wires, ropes, and chains, to crane hook.<br>\uf0b7Sets up, braces, and rigs hoisting equipment, using hand tools and power wrenches.<br>\uf0b7May direct workers engaged in hoisting of machinery and equipment.<\/p>","%category%":"","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/94712b73663b-mining-maintenance-mechanic","%breezy_id%":"94712b73663b","%breezy_friendly_id%":"94712b73663b-mining-maintenance-mechanic","%breezy_created_date%":"2024-08-21T17:37:09.346Z","%breezy_updated_date%":"2025-05-19T15:01:42.173Z","%_wpgmp_location_city%":"Ely","%_wpgmp_location_state%":"NV","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Ely, NV, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"39.2533328","%_wpgmp_metabox_longitude%":"-114.874248","%rank_math_internal_links_processed%":"1"}},"id":1680,"infowindow_disable":false},{"source":"post","title":"Heavy Equipment Mechanic (Drill\/Shovel)","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Heavy Equipment Mechanic (Drill\/Shovel)\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    This person will function as a heavy equipment mechanic and should maintain a&nbsp;willingness to do, learn, perform and improve any&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/heavy-equipment-mechanic-drill-shovel\/\" name=\"Heavy Equipment Mechanic (Drill\/Shovel)\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"This person will function as a heavy equipment mechanic and should maintain a&nbsp;willingness to do, learn, perform and improve any&hellip;","address":"Eureka Area, NV, USA","location":{"lat":"39.5124858","city":"Eureka Area","state":"NV","country":"United States","lng":"-115.9607803","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/heavy-equipment-mechanic-drill-shovel\/","zoom":19,"extra_fields":{"post_excerpt":"This person will function as a heavy equipment mechanic and should maintain a&nbsp;willingness to do, learn, perform and improve any&hellip;","post_content":"<p>This person will function as a heavy equipment mechanic and should maintain a&nbsp;willingness to do, learn, perform and improve any maintenance task. They will specifically be working on drills\/shovels.&nbsp;<\/p><p>This person should have experience with the following:<\/p><p>-Diagnostics and troubleshooting<br>-Welding<br>-3-5 years of mechanical experience<br>-Knowledge to maintain\/repair AC, hydraulic, electrical, compressed air, and powertrain systems<br>-Knowledge to maintain\/repair braking and steering systems&nbsp;<br>-Knowledge to maintain\/repair engine overheads and procedures<br>-Lifting and rigging<\/p><p><br><\/p><p><\/p><p><\/p>","post_title":"Heavy Equipment Mechanic (Drill\/Shovel)","post_link":"https:\/\/turnerstaffing.com\/position\/heavy-equipment-mechanic-drill-shovel\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"","%location_country%":"United States","%location_city%":"Eureka Area","%location_state_id%":"NV","%location_state_name%":"Nevada","%location_city_state%":"Eureka Area, NV","%education%":"","%department%":"","%description%":"<p>This person will function as a heavy equipment mechanic and should maintain a&nbsp;willingness to do, learn, perform and improve any maintenance task. They will specifically be working on drills\/shovels.&nbsp;<\/p><p>This person should have experience with the following:<\/p><p>-Diagnostics and troubleshooting<br>-Welding<br>-3-5 years of mechanical experience<br>-Knowledge to maintain\/repair AC, hydraulic, electrical, compressed air, and powertrain systems<br>-Knowledge to maintain\/repair braking and steering systems&nbsp;<br>-Knowledge to maintain\/repair engine overheads and procedures<br>-Lifting and rigging<\/p><p><br><\/p><p><\/p><p><\/p>","%category%":"","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/c94002623d85-heavy-equipment-mechanic-drill-shovel","%breezy_id%":"c94002623d85","%breezy_friendly_id%":"c94002623d85-heavy-equipment-mechanic-drill-shovel","%breezy_created_date%":"2024-07-17T19:26:24.259Z","%breezy_updated_date%":"2025-05-20T19:15:04.273Z","%_wpgmp_location_city%":"Eureka Area","%_wpgmp_location_state%":"NV","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Eureka Area, NV, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"39.5124858","%_wpgmp_metabox_longitude%":"-115.9607803","%rank_math_internal_links_processed%":"1"}},"id":1588,"infowindow_disable":false},{"source":"post","title":"Heavy Equipment Mechanic","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Heavy Equipment Mechanic\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    This person will function as a heavy equipment mechanic and should maintain a willingness to do, learn, perform and improve&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/heavy-equipment-mechanic-5\/\" name=\"Heavy Equipment Mechanic\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"This person will function as a heavy equipment mechanic and should maintain a willingness to do, learn, perform and improve&hellip;","address":"Eureka Area, NV, USA","location":{"lat":"39.5124858","city":"Eureka Area","state":"NV","country":"United States","lng":"-115.9607803","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/heavy-equipment-mechanic-5\/","zoom":19,"extra_fields":{"post_excerpt":"This person will function as a heavy equipment mechanic and should maintain a willingness to do, learn, perform and improve&hellip;","post_content":"<p>This person will function as a heavy equipment mechanic and should maintain a willingness to do, learn, perform and improve any maintenance task. They will be working on a variety of heavy-duty earthmoving equipment.&nbsp;<\/p><p>This person should have experience with the following:<br>-Diagnostics and troubleshooting<br>-Welding<br>-3-5 years of mechanical experience<br>-Knowledge to maintain\/repair AC, hydraulic, electrical, compressed air, and powertrain systems<br>-Knowledge to maintain\/repair braking and steering systems<br>-Knowledge to maintain\/repair engine overheads and procedures<br>&nbsp;-Lifting and rigging<\/p>","post_title":"Heavy Equipment Mechanic","post_link":"https:\/\/turnerstaffing.com\/position\/heavy-equipment-mechanic-5\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"","%location_country%":"United States","%location_city%":"Eureka Area","%location_state_id%":"NV","%location_state_name%":"Nevada","%location_city_state%":"Eureka Area, NV","%education%":"","%department%":"","%description%":"<p>This person will function as a heavy equipment mechanic and should maintain a willingness to do, learn, perform and improve any maintenance task. They will be working on a variety of heavy-duty earthmoving equipment.&nbsp;<\/p><p>This person should have experience with the following:<br>-Diagnostics and troubleshooting<br>-Welding<br>-3-5 years of mechanical experience<br>-Knowledge to maintain\/repair AC, hydraulic, electrical, compressed air, and powertrain systems<br>-Knowledge to maintain\/repair braking and steering systems<br>-Knowledge to maintain\/repair engine overheads and procedures<br>&nbsp;-Lifting and rigging<\/p>","%category%":"","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/871f7d6ef660-heavy-equipment-mechanic","%breezy_id%":"871f7d6ef660","%breezy_friendly_id%":"871f7d6ef660-heavy-equipment-mechanic","%breezy_created_date%":"2024-07-17T19:32:50.703Z","%breezy_updated_date%":"2025-05-20T19:15:02.237Z","%_wpgmp_location_city%":"Eureka Area","%_wpgmp_location_state%":"NV","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Eureka Area, NV, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"39.5124858","%_wpgmp_metabox_longitude%":"-115.9607803","%rank_math_internal_links_processed%":"1"}},"id":1589,"infowindow_disable":false},{"source":"post","title":"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-05-20T19:16:43.529Z","%_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":"Industrial Electrician","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Industrial Electrician\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Round Mountain is an open-pit mine located in Nevada, one of the best mining jurisdictions in the world. The mine&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/industrial-electrician-7\/\" name=\"Industrial Electrician\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Round Mountain is an open-pit mine located in Nevada, one of the best mining jurisdictions in the world. The mine&hellip;","address":"Round Mountain, NV, USA","location":{"lat":"38.7110428","city":"Round Mountain","state":"NV","country":"United States","lng":"-117.0675843","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/industrial-electrician-7\/","zoom":19,"extra_fields":{"post_excerpt":"Round Mountain is an open-pit mine located in Nevada, one of the best mining jurisdictions in the world. The mine&hellip;","post_content":"<p>Round Mountain is an open-pit mine located in Nevada, one of the best mining jurisdictions in the world. The mine uses conventional open-pit mining methods and processes ore by mill and heap leach.&nbsp;<\/p>\n<p>The Round Mountain mine is an important contributor to the Nye County economy and, working with local stakeholders, has helped achieve significant improvements in healthcare and education in the area.<\/p>\n<h2>Job Description<\/h2>\n<p>Under the general supervision of the Electrical Maintenance Supervisor, the incumbent oversees every aspect of the electrical systems on the mine site, and is responsible for their repair and maintenance.<\/p>\n<h2>Job Responsibilities<\/h2>\n<ul><li>Maintain, troubleshoot, and repair AC\/DC drive systems, AC\/DC motors, electrical shovel, electrical power distribution, protection systems, metering, PLC\u2019s, and lighting systems.<\/li><li>Moving, hauling, and lifting equipment as required by the repair or maintenance being performed.<\/li><li>Learn to order parts, and specify certain parts when ordering, and complete appropriate paperwork.<\/li><li>Train for higher levels of responsibility.<\/li><li>Responsible to manage the RMGC Environmental Health and Safety Management system in his\/her areas of responsibility.<\/li><li>Compliance with all company policies and procedures including, but not limited to safety, environmental, confidentiality and code of conduct.<\/li><li>Meets or exceeds established performance expectations set by management.<\/li><li>Consistently exercises discretion and judgment in job performance.<\/li><li>Works without risk or harm to self and others.<\/li><li>Punctuality and regular attendance required.<\/li><li>Helps develop other department personnel to perform duties listed above.<\/li><li>Performs other related functions as assigned by supervisor.<\/li><\/ul>\n<h2>Education and Experience<\/h2>\n<ul><li>Knowledge of electronics and electrical power.<\/li><li>Be constantly aware of personal safety.&nbsp;&nbsp; The incumbent must understand what actions can lead to dangerous reactions and know the proper steps to take in order to perform each job safely.<\/li><li>Capable of lifting and hauling equipment necessary to complete each job.<\/li><li>Be able to accurately complete appropriate paperwork associated with ordering parts.&nbsp;<\/li><li>Electrical background required; either a college or technical degree or Journeyman.<\/li><li>Work will be performed both indoors and outdoors in a general industrial environment.&nbsp;&nbsp; The incumbent may be asked to work straight days or shiftwork with overtime as needed.&nbsp;&nbsp; Appropriate PPE must be worn at all times.<\/li><li>Possesses good communication and interpersonal skills.<\/li><li>General understanding of mining operations, as well as limited understanding of milling and maintenance operations.<\/li><li>Working knowledge and skill with P.C. utilizing word processing, spreadsheet, database, and presentation software.<\/li><li>Strong verbal, written, analytical and persuasive skills and the ability to interact effectively with all levels of employees and management.<\/li><li>Ability to work independently and also as a member of the management team.<\/li><li>Demonstrates strong administrative, organizational and technical writing skills.<\/li><li>Must be 18 years old and presently authorized to work in the United States on a full time basis.<\/li><li>Requires valid driver\u2019s license.<\/li><\/ul>","post_title":"Industrial Electrician","post_link":"https:\/\/turnerstaffing.com\/position\/industrial-electrician-7\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"","%location_country%":"United States","%location_city%":"Round Mountain","%location_state_id%":"NV","%location_state_name%":"Nevada","%location_city_state%":"Round Mountain, NV","%education%":"","%department%":"","%description%":"<p>Round Mountain is an open-pit mine located in Nevada, one of the best mining jurisdictions in the world. The mine uses conventional open-pit mining methods and processes ore by mill and heap leach.&nbsp;<\/p>\n<p>The Round Mountain mine is an important contributor to the Nye County economy and, working with local stakeholders, has helped achieve significant improvements in healthcare and education in the area.<\/p>\n<h2>Job Description<\/h2>\n<p>Under the general supervision of the Electrical Maintenance Supervisor, the incumbent oversees every aspect of the electrical systems on the mine site, and is responsible for their repair and maintenance.<\/p>\n<h2>Job Responsibilities<\/h2>\n<ul><li>Maintain, troubleshoot, and repair AC\/DC drive systems, AC\/DC motors, electrical shovel, electrical power distribution, protection systems, metering, PLC\u2019s, and lighting systems.<\/li><li>Moving, hauling, and lifting equipment as required by the repair or maintenance being performed.<\/li><li>Learn to order parts, and specify certain parts when ordering, and complete appropriate paperwork.<\/li><li>Train for higher levels of responsibility.<\/li><li>Responsible to manage the RMGC Environmental Health and Safety Management system in his\/her areas of responsibility.<\/li><li>Compliance with all company policies and procedures including, but not limited to safety, environmental, confidentiality and code of conduct.<\/li><li>Meets or exceeds established performance expectations set by management.<\/li><li>Consistently exercises discretion and judgment in job performance.<\/li><li>Works without risk or harm to self and others.<\/li><li>Punctuality and regular attendance required.<\/li><li>Helps develop other department personnel to perform duties listed above.<\/li><li>Performs other related functions as assigned by supervisor.<\/li><\/ul>\n<h2>Education and Experience<\/h2>\n<ul><li>Knowledge of electronics and electrical power.<\/li><li>Be constantly aware of personal safety.&nbsp;&nbsp; The incumbent must understand what actions can lead to dangerous reactions and know the proper steps to take in order to perform each job safely.<\/li><li>Capable of lifting and hauling equipment necessary to complete each job.<\/li><li>Be able to accurately complete appropriate paperwork associated with ordering parts.&nbsp;<\/li><li>Electrical background required; either a college or technical degree or Journeyman.<\/li><li>Work will be performed both indoors and outdoors in a general industrial environment.&nbsp;&nbsp; The incumbent may be asked to work straight days or shiftwork with overtime as needed.&nbsp;&nbsp; Appropriate PPE must be worn at all times.<\/li><li>Possesses good communication and interpersonal skills.<\/li><li>General understanding of mining operations, as well as limited understanding of milling and maintenance operations.<\/li><li>Working knowledge and skill with P.C. utilizing word processing, spreadsheet, database, and presentation software.<\/li><li>Strong verbal, written, analytical and persuasive skills and the ability to interact effectively with all levels of employees and management.<\/li><li>Ability to work independently and also as a member of the management team.<\/li><li>Demonstrates strong administrative, organizational and technical writing skills.<\/li><li>Must be 18 years old and presently authorized to work in the United States on a full time basis.<\/li><li>Requires valid driver\u2019s license.<\/li><\/ul>","%category%":"","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/2321c15d849f-industrial-electrician","%breezy_id%":"2321c15d849f","%breezy_friendly_id%":"2321c15d849f-industrial-electrician","%breezy_created_date%":"2024-05-14T14:15:31.648Z","%breezy_updated_date%":"2025-05-20T19:16:02.188Z","%_wpgmp_location_city%":"Round Mountain","%_wpgmp_location_state%":"NV","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Round Mountain, NV, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"38.7110428","%_wpgmp_metabox_longitude%":"-117.0675843","%rank_math_internal_links_processed%":"1","%rank_math_analytic_object_id%":"14"}},"id":1386,"infowindow_disable":false},{"source":"post","title":"Light Vehicle Mechanic","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Light Vehicle Mechanic\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Job Title: Light Vehicle Mechanic Location: Elko, NV Job Description: As a Light Vehicle Mechanic, you will be responsible for&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/light-vehicle-mechanic\/\" name=\"Light Vehicle Mechanic\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Job Title: Light Vehicle Mechanic Location: Elko, NV Job Description: As a Light Vehicle Mechanic, you will be responsible for&hellip;","address":"Elko, NV, USA","location":{"lat":"40.8436459","city":"Elko","state":"NV","country":"United States","lng":"-115.7526187","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/light-vehicle-mechanic\/","zoom":19,"extra_fields":{"post_excerpt":"Job Title: Light Vehicle Mechanic Location: Elko, NV Job Description: As a Light Vehicle Mechanic, you will be responsible for&hellip;","post_content":"<p><strong><br>Job Title: Light Vehicle Mechanic<\/strong><br><\/p>\n\n<p><strong>Location: Elko, NV<\/strong><br><\/p>\n\n<p><strong>Job Description:<\/strong><\/p>\n<p>As a Light Vehicle Mechanic, you will be responsible for maintaining, diagnosing, and repairing light vehicles used in mining operations. Your expertise will ensure the reliability and safety of the company's fleet, contributing to the overall efficiency of mining activities.<\/p>\n<p><strong>Key Responsibilities:<\/strong><\/p>\n<ol><li><strong>Vehicle Maintenance:<\/strong> Perform routine maintenance tasks, including oil changes, filter replacements, tire rotations, and fluid checks, to keep light vehicles in optimal condition.<\/li><li><strong>Diagnosis and Repair:<\/strong> Troubleshoot and diagnose mechanical, electrical, and hydraulic issues in light vehicles, such as trucks, vans, and SUVs. Conduct repairs and replacements of faulty components to restore functionality.<\/li><li><strong>Inspections and Testing:<\/strong> Conduct thorough inspections of vehicles to identify any potential problems or safety concerns. Perform diagnostic tests and quality checks to ensure vehicles meet performance and safety standards.<\/li><li><strong>Parts and Inventory Management:<\/strong> Maintain accurate records of parts inventory and requisition supplies as needed. Coordinate with suppliers to procure replacement parts and ensure timely repairs.<\/li><li><strong>Safety Compliance:<\/strong> Adhere to all safety protocols and procedures to create a safe working environment. Ensure that vehicles are maintained in compliance with regulatory requirements and industry standards.<\/li><li><strong>Documentation:<\/strong> Complete detailed service reports, maintenance logs, and repair records to document work performed and track vehicle history. Maintain organized records for compliance and reference purposes.<\/li><li><strong>Team Collaboration:<\/strong> Work collaboratively with other members of the maintenance team and mining operations staff to coordinate vehicle maintenance activities and support overall operational goals.<\/li><\/ol>\n<p><strong>Qualifications:<\/strong><\/p>\n<ul><li>Proven experience as a light vehicle mechanic, preferably in a mining or heavy equipment environment.<\/li><li>Proficiency in diagnosing and repairing mechanical, electrical, and hydraulic systems in light vehicles.<\/li><li>Strong knowledge of automotive systems, components, and diagnostic tools.<\/li><li>Familiarity with safety regulations and best practices in vehicle maintenance.<\/li><li>Excellent problem-solving skills and attention to detail.<\/li><li>Ability to work independently and as part of a team in a fast-paced environment.<\/li><li>Valid driver's license and clean driving record.<\/li><li>Certification from a recognized automotive training program or equivalent experience is preferred.<\/li><\/ul>\n<p><strong>Benefits:<\/strong><\/p>\n<ul><li>Competitive salary commensurate with experience.<\/li><li>Comprehensive benefits package, including health insurance, retirement plans, and paid time off.<\/li><li>Opportunities for career advancement and professional development within the mining industry.<\/li><li>Supportive work environment with a focus on safety and teamwork.<\/li><\/ul>\n<p>Join our team and play a vital role in maintaining the reliability and efficiency of our light vehicle fleet. Apply now to become a Light Vehicle Mechanic with Turner Staffing Group and our partner mining company!<\/p>","post_title":"Light Vehicle Mechanic","post_link":"https:\/\/turnerstaffing.com\/position\/light-vehicle-mechanic\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Associate","%location_country%":"United States","%location_city%":"Elko","%location_state_id%":"NV","%location_state_name%":"Nevada","%location_city_state%":"Elko, NV","%education%":"Unspecified","%department%":"Equipment","%description%":"<p><strong><br>Job Title: Light Vehicle Mechanic<\/strong><br><\/p>\n\n<p><strong>Location: Elko, NV<\/strong><br><\/p>\n\n<p><strong>Job Description:<\/strong><\/p>\n<p>As a Light Vehicle Mechanic, you will be responsible for maintaining, diagnosing, and repairing light vehicles used in mining operations. Your expertise will ensure the reliability and safety of the company's fleet, contributing to the overall efficiency of mining activities.<\/p>\n<p><strong>Key Responsibilities:<\/strong><\/p>\n<ol><li><strong>Vehicle Maintenance:<\/strong> Perform routine maintenance tasks, including oil changes, filter replacements, tire rotations, and fluid checks, to keep light vehicles in optimal condition.<\/li><li><strong>Diagnosis and Repair:<\/strong> Troubleshoot and diagnose mechanical, electrical, and hydraulic issues in light vehicles, such as trucks, vans, and SUVs. Conduct repairs and replacements of faulty components to restore functionality.<\/li><li><strong>Inspections and Testing:<\/strong> Conduct thorough inspections of vehicles to identify any potential problems or safety concerns. Perform diagnostic tests and quality checks to ensure vehicles meet performance and safety standards.<\/li><li><strong>Parts and Inventory Management:<\/strong> Maintain accurate records of parts inventory and requisition supplies as needed. Coordinate with suppliers to procure replacement parts and ensure timely repairs.<\/li><li><strong>Safety Compliance:<\/strong> Adhere to all safety protocols and procedures to create a safe working environment. Ensure that vehicles are maintained in compliance with regulatory requirements and industry standards.<\/li><li><strong>Documentation:<\/strong> Complete detailed service reports, maintenance logs, and repair records to document work performed and track vehicle history. Maintain organized records for compliance and reference purposes.<\/li><li><strong>Team Collaboration:<\/strong> Work collaboratively with other members of the maintenance team and mining operations staff to coordinate vehicle maintenance activities and support overall operational goals.<\/li><\/ol>\n<p><strong>Qualifications:<\/strong><\/p>\n<ul><li>Proven experience as a light vehicle mechanic, preferably in a mining or heavy equipment environment.<\/li><li>Proficiency in diagnosing and repairing mechanical, electrical, and hydraulic systems in light vehicles.<\/li><li>Strong knowledge of automotive systems, components, and diagnostic tools.<\/li><li>Familiarity with safety regulations and best practices in vehicle maintenance.<\/li><li>Excellent problem-solving skills and attention to detail.<\/li><li>Ability to work independently and as part of a team in a fast-paced environment.<\/li><li>Valid driver's license and clean driving record.<\/li><li>Certification from a recognized automotive training program or equivalent experience is preferred.<\/li><\/ul>\n<p><strong>Benefits:<\/strong><\/p>\n<ul><li>Competitive salary commensurate with experience.<\/li><li>Comprehensive benefits package, including health insurance, retirement plans, and paid time off.<\/li><li>Opportunities for career advancement and professional development within the mining industry.<\/li><li>Supportive work environment with a focus on safety and teamwork.<\/li><\/ul>\n<p>Join our team and play a vital role in maintaining the reliability and efficiency of our light vehicle fleet. Apply now to become a Light Vehicle Mechanic with Turner Staffing Group and our partner mining company!<\/p>","%category%":"Operations","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/8a4f13b949cf-light-vehicle-mechanic","%breezy_id%":"8a4f13b949cf","%breezy_friendly_id%":"8a4f13b949cf-light-vehicle-mechanic","%breezy_created_date%":"2024-04-09T15:05:16.423Z","%breezy_updated_date%":"2025-05-20T19:16:40.830Z","%_wpgmp_location_city%":"Elko","%_wpgmp_location_state%":"NV","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Elko, NV, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"40.8436459","%_wpgmp_metabox_longitude%":"-115.7526187","%rank_math_internal_links_processed%":"1","%rank_math_analytic_object_id%":"47"}},"id":1326,"infowindow_disable":false},{"source":"post","title":"High Voltage Electrician","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    High Voltage Electrician\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Job Title: High Voltage ElectricianCompany:&nbsp;Turner Staffing GroupLocation: Nevada, USAEmployment Type: Full-time About Us:Turner Staffing Group is partnered with a leading&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/high-voltage-electrician\/\" name=\"High Voltage Electrician\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Job Title: High Voltage ElectricianCompany:&nbsp;Turner Staffing GroupLocation: Nevada, USAEmployment Type: Full-time About Us:Turner Staffing Group is partnered with a leading&hellip;","address":"Elko, NV, USA","location":{"lat":"40.8436459","city":"Elko","state":"NV","country":"United States","lng":"-115.7526187","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/high-voltage-electrician\/","zoom":19,"extra_fields":{"post_excerpt":"Job Title: High Voltage ElectricianCompany:&nbsp;Turner Staffing GroupLocation: Nevada, USAEmployment Type: Full-time About Us:Turner Staffing Group is partnered with a leading&hellip;","post_content":"<p><strong>Job Title:<\/strong> High Voltage Electrician<br><strong>Company:<\/strong>&nbsp;Turner Staffing Group<br><strong>Location:<\/strong> Nevada, USA<br><strong>Employment Type:<\/strong> Full-time<\/p>\n<p><strong>About Us:<\/strong><br>Turner Staffing Group is partnered with a leading player in the gold mining industry, operating in Nevada with a commitment to excellence in safety, sustainability, and productivity. Partnered with Turner Staffing Group, we are currently seeking a skilled High Voltage Electrician to join our team.<\/p>\n<p><strong>Job Description:<\/strong><br>As a High Voltage Electrician, you will be responsible for the maintenance, repair, and installation of high voltage electrical systems and equipment within our mining operations. This role will involve working with a team of professionals to ensure the safe and efficient operation of electrical infrastructure critical to our mining processes.<\/p>\n<p><strong>Key Responsibilities:<\/strong><\/p>\n<ul><li>Perform routine inspections, troubleshooting, and maintenance of high voltage electrical systems, including transformers, switchgear, and distribution lines.<\/li><li>Conduct repairs and replacements of faulty components to minimize downtime and ensure continuous operation of equipment.<\/li><li>Collaborate with engineering and maintenance teams to plan and execute electrical projects, upgrades, and expansions.<\/li><li>Adhere to safety protocols and regulatory standards to maintain a safe working environment for yourself and your team.<\/li><li>Document work activities, including inspections, repairs, and maintenance tasks, to maintain accurate records and facilitate effective communication.<\/li><\/ul>\n<p><strong>Requirements:<\/strong><\/p>\n<ul><li>High school diploma or equivalent; completion of a recognized electrical apprenticeship program preferred.<\/li><li>Journeyman Electrician license or equivalent certification required.<\/li><li>Minimum of 3 years of experience working with high voltage electrical systems, preferably in an industrial or mining environment.<\/li><li>Strong knowledge of electrical principles, codes, and regulations, with a focus on high voltage systems (4160V and above).<\/li><li>Ability to interpret electrical schematics, diagrams, and technical documentation.<\/li><li>Excellent problem-solving skills and attention to detail.<\/li><li>Effective communication and teamwork abilities.<\/li><li>Willingness to work in a dynamic and physically demanding environment, including outdoor and underground settings as required.<\/li><\/ul>\n<p><strong>Benefits:<\/strong><\/p>\n<ul><li>Competitive salary commensurate with experience.<\/li><li>Comprehensive benefits package, including medical, dental, vision, and retirement plans.<\/li><li>Opportunities for career growth and advancement within a leading mining organization.<\/li><li>Training and development programs to enhance your skills and knowledge.<\/li><li>A supportive work environment with a focus on safety and collaboration.<\/li><\/ul>\n<p><strong>How to Apply:<\/strong><br>If you are a qualified High Voltage Electrician looking for an exciting opportunity to contribute to the success of a dynamic mining operation, please submit your resume and cover letter through the Turner Staffing Group website!<\/p>\n<p>Turner Staffing Group is an equal opportunity employers committed to diversity and inclusion in the workplace.<\/p>","post_title":"High Voltage Electrician","post_link":"https:\/\/turnerstaffing.com\/position\/high-voltage-electrician\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Associate","%location_country%":"United States","%location_city%":"Elko","%location_state_id%":"NV","%location_state_name%":"Nevada","%location_city_state%":"Elko, NV","%education%":"High School or equivalent","%department%":"Operations","%description%":"<p><strong>Job Title:<\/strong> High Voltage Electrician<br><strong>Company:<\/strong>&nbsp;Turner Staffing Group<br><strong>Location:<\/strong> Nevada, USA<br><strong>Employment Type:<\/strong> Full-time<\/p>\n<p><strong>About Us:<\/strong><br>Turner Staffing Group is partnered with a leading player in the gold mining industry, operating in Nevada with a commitment to excellence in safety, sustainability, and productivity. Partnered with Turner Staffing Group, we are currently seeking a skilled High Voltage Electrician to join our team.<\/p>\n<p><strong>Job Description:<\/strong><br>As a High Voltage Electrician, you will be responsible for the maintenance, repair, and installation of high voltage electrical systems and equipment within our mining operations. This role will involve working with a team of professionals to ensure the safe and efficient operation of electrical infrastructure critical to our mining processes.<\/p>\n<p><strong>Key Responsibilities:<\/strong><\/p>\n<ul><li>Perform routine inspections, troubleshooting, and maintenance of high voltage electrical systems, including transformers, switchgear, and distribution lines.<\/li><li>Conduct repairs and replacements of faulty components to minimize downtime and ensure continuous operation of equipment.<\/li><li>Collaborate with engineering and maintenance teams to plan and execute electrical projects, upgrades, and expansions.<\/li><li>Adhere to safety protocols and regulatory standards to maintain a safe working environment for yourself and your team.<\/li><li>Document work activities, including inspections, repairs, and maintenance tasks, to maintain accurate records and facilitate effective communication.<\/li><\/ul>\n<p><strong>Requirements:<\/strong><\/p>\n<ul><li>High school diploma or equivalent; completion of a recognized electrical apprenticeship program preferred.<\/li><li>Journeyman Electrician license or equivalent certification required.<\/li><li>Minimum of 3 years of experience working with high voltage electrical systems, preferably in an industrial or mining environment.<\/li><li>Strong knowledge of electrical principles, codes, and regulations, with a focus on high voltage systems (4160V and above).<\/li><li>Ability to interpret electrical schematics, diagrams, and technical documentation.<\/li><li>Excellent problem-solving skills and attention to detail.<\/li><li>Effective communication and teamwork abilities.<\/li><li>Willingness to work in a dynamic and physically demanding environment, including outdoor and underground settings as required.<\/li><\/ul>\n<p><strong>Benefits:<\/strong><\/p>\n<ul><li>Competitive salary commensurate with experience.<\/li><li>Comprehensive benefits package, including medical, dental, vision, and retirement plans.<\/li><li>Opportunities for career growth and advancement within a leading mining organization.<\/li><li>Training and development programs to enhance your skills and knowledge.<\/li><li>A supportive work environment with a focus on safety and collaboration.<\/li><\/ul>\n<p><strong>How to Apply:<\/strong><br>If you are a qualified High Voltage Electrician looking for an exciting opportunity to contribute to the success of a dynamic mining operation, please submit your resume and cover letter through the Turner Staffing Group website!<\/p>\n<p>Turner Staffing Group is an equal opportunity employers committed to diversity and inclusion in the workplace.<\/p>","%category%":"Operations","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/9e5a721f0c7b-high-voltage-electrician","%breezy_id%":"9e5a721f0c7b","%breezy_friendly_id%":"9e5a721f0c7b-high-voltage-electrician","%breezy_created_date%":"2024-03-12T14:52:31.591Z","%breezy_updated_date%":"2025-05-20T19:15:39.951Z","%_wpgmp_location_city%":"Elko","%_wpgmp_location_state%":"NV","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Elko, NV, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"40.8436459","%_wpgmp_metabox_longitude%":"-115.7526187","%rank_math_internal_links_processed%":"1","%rank_math_analytic_object_id%":"59"}},"id":1216,"infowindow_disable":false},{"source":"post","title":"Heavy Equipment Mechanic","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Heavy Equipment Mechanic\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Heavy Equipment Mechanic Do you love mining? Do you think differently? Are you ready to define the future of this&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/heavy-equipment-mechanic-9\/\" name=\"Heavy Equipment Mechanic\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Heavy Equipment Mechanic Do you love mining? Do you think differently? Are you ready to define the future of this&hellip;","address":"Hadley, NV, USA","location":{"lat":"38.6943762","city":"Hadley","state":"NV","country":"United States","lng":"-117.160364","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/heavy-equipment-mechanic-9\/","zoom":19,"extra_fields":{"post_excerpt":"Heavy Equipment Mechanic Do you love mining? Do you think differently? Are you ready to define the future of this&hellip;","post_content":"<p><strong><u>Heavy Equipment Mechanic<\/u><\/strong><\/p>\n<p>Do you love mining? Do you think differently? Are you ready to define the future of this industry?<\/p>\n<p>We\u2019ve been waiting for you! Turner Staffing Group is committed to changing the way mining companies do business. We develop our people. We partner with our clients. We believe in win, win, win.<\/p>\n<p>We are looking for a dynamic and talented professional to fill a Heavy Equipment Mechanic role at our fast-growing, forward thinking mining services company.<\/p>\n<p>Turner Staffing Group is seeking an energetic professional who can leverage their Heavy Equipment knowledge to expand upon our fast-growing business, creating best practices for systems and scalable business processes to ensure profitable operations. This person will function as a Heavy Equipment Mechanic, willingness to do, learn, perform and improve any maintenance task. Tasks will be defined and evolve in all areas of mining operations to ensure preventative maintenance is practiced, repairs, equipment runs in the area of responsibility. You will report to and work with the Project Superintendent to develop heavy equipment procedures that will ensure safe operations. This is an opportunity to work as part of the operations team in a safe, productive, and fun environment.<\/p>\n<p><u><strong>You<\/strong><\/u><br>\nYou want to work for a services company that is rapidly changing the way the largest materials producers do business. You are motivated by solving problems and partnering with our clients and suppliers. You want to work with great people and enjoy being a part of a strong team. You are a knowledgeable Heavy Equipment Mechanic professional who is not afraid to jump into every detail. You want to be in a place where continuous learning and growth is the norm. You are adaptable and able to juggle multiple initiatives concurrently.<\/p>\n<p><strong><u>Essential Skills &amp; Knowledge<\/u><\/strong><\/p>\n<p>\u2022 Follow a consistent and regular schedule to perform various types of maintenance on heavy equipment and various pieces of machinery<\/p>\n<p>\u2022 Perform repairs on equipment using tools, machine tools and measuring instruments<\/p>\n<p>\u2022 Diagnose and troubleshoot fuel systems, electrical systems, hydraulic systems and propane systems<\/p>\n<p>\u2022 Conduct oil changes, lubrication of equipment, tire replacements, hose repairs, battery replacements and assorted services<\/p>\n<p>\u2022 Recondition and replace parts of the heavy equipment<\/p>\n<p>\u2022 Operate and test equipment<\/p>\n<p>\u2022 Diagnoses problem areas for any significant wear or tear on the equipment<\/p>\n<p>\u2022 Produce detailed service reports and repair logs<\/p>\n<p>\u2022 Follow all established procedures and protocols<\/p>\n<p>\u2022 Build positive relationships with internal and external teams<\/p>\n<p>\u2022 Perform additional duties as assigned<\/p>\n<p><strong><u>Benefits<\/u><\/strong><\/p>\n<p>Turner Staffing Group offers a competitive salary, an excellent work culture, career advancement opportunities. Our team offers a benefits program which includes Medical, Dental, Vision, Life, and a 401k with company match. We believe in a work life balance and established paid time off for major holidays.<\/p>\n<p>At Turner Staffing Group, we encourage and celebrate an inclusive environment for all employees and are proud to be an equal opportunity workplace and affirmative action employer.<\/p>","post_title":"Heavy Equipment Mechanic","post_link":"https:\/\/turnerstaffing.com\/position\/heavy-equipment-mechanic-9\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Associate","%location_country%":"United States","%location_city%":"Hadley","%location_state_id%":"NV","%location_state_name%":"Nevada","%location_city_state%":"Hadley, NV","%education%":"High School or equivalent","%department%":"","%description%":"<p><strong><u>Heavy Equipment Mechanic<\/u><\/strong><\/p>\n<p>Do you love mining? Do you think differently? Are you ready to define the future of this industry?<\/p>\n<p>We\u2019ve been waiting for you! Turner Staffing Group is committed to changing the way mining companies do business. We develop our people. We partner with our clients. We believe in win, win, win.<\/p>\n<p>We are looking for a dynamic and talented professional to fill a Heavy Equipment Mechanic role at our fast-growing, forward thinking mining services company.<\/p>\n<p>Turner Staffing Group is seeking an energetic professional who can leverage their Heavy Equipment knowledge to expand upon our fast-growing business, creating best practices for systems and scalable business processes to ensure profitable operations. This person will function as a Heavy Equipment Mechanic, willingness to do, learn, perform and improve any maintenance task. Tasks will be defined and evolve in all areas of mining operations to ensure preventative maintenance is practiced, repairs, equipment runs in the area of responsibility. You will report to and work with the Project Superintendent to develop heavy equipment procedures that will ensure safe operations. This is an opportunity to work as part of the operations team in a safe, productive, and fun environment.<\/p>\n<p><u><strong>You<\/strong><\/u><br>\nYou want to work for a services company that is rapidly changing the way the largest materials producers do business. You are motivated by solving problems and partnering with our clients and suppliers. You want to work with great people and enjoy being a part of a strong team. You are a knowledgeable Heavy Equipment Mechanic professional who is not afraid to jump into every detail. You want to be in a place where continuous learning and growth is the norm. You are adaptable and able to juggle multiple initiatives concurrently.<\/p>\n<p><strong><u>Essential Skills &amp; Knowledge<\/u><\/strong><\/p>\n<p>\u2022 Follow a consistent and regular schedule to perform various types of maintenance on heavy equipment and various pieces of machinery<\/p>\n<p>\u2022 Perform repairs on equipment using tools, machine tools and measuring instruments<\/p>\n<p>\u2022 Diagnose and troubleshoot fuel systems, electrical systems, hydraulic systems and propane systems<\/p>\n<p>\u2022 Conduct oil changes, lubrication of equipment, tire replacements, hose repairs, battery replacements and assorted services<\/p>\n<p>\u2022 Recondition and replace parts of the heavy equipment<\/p>\n<p>\u2022 Operate and test equipment<\/p>\n<p>\u2022 Diagnoses problem areas for any significant wear or tear on the equipment<\/p>\n<p>\u2022 Produce detailed service reports and repair logs<\/p>\n<p>\u2022 Follow all established procedures and protocols<\/p>\n<p>\u2022 Build positive relationships with internal and external teams<\/p>\n<p>\u2022 Perform additional duties as assigned<\/p>\n<p><strong><u>Benefits<\/u><\/strong><\/p>\n<p>Turner Staffing Group offers a competitive salary, an excellent work culture, career advancement opportunities. Our team offers a benefits program which includes Medical, Dental, Vision, Life, and a 401k with company match. We believe in a work life balance and established paid time off for major holidays.<\/p>\n<p>At Turner Staffing Group, we encourage and celebrate an inclusive environment for all employees and are proud to be an equal opportunity workplace and affirmative action employer.<\/p>","%category%":"Other","%breezy_id%":"c28e984fcb8d","%breezy_friendly_id%":"c28e984fcb8d-heavy-equipment-mechanic","%breezy_created_date%":"2023-11-27T15:16:09.094Z","%breezy_updated_date%":"2025-05-20T19:15:00.440Z","%rank_math_internal_links_processed%":"1","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/c28e984fcb8d-heavy-equipment-mechanic","%_wpgmp_location_city%":"Hadley","%_wpgmp_location_state%":"NV","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Hadley, NV, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"38.6943762","%_wpgmp_metabox_longitude%":"-117.160364","%rank_math_analytic_object_id%":"81"}},"id":883,"infowindow_disable":false},{"source":"post","title":"Heavy Equipment Mechanic","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Heavy Equipment Mechanic\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Heavy Equipment Mechanic&nbsp; Do you love mining? Do you think differently? Are you ready to define the future of this&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/heavy-equipment-mechanic-3\/\" name=\"Heavy Equipment Mechanic\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Heavy Equipment Mechanic&nbsp; Do you love mining? Do you think differently? Are you ready to define the future of this&hellip;","address":"Elko, NV, USA","location":{"lat":"40.8436459","city":"Elko","state":"NV","country":"United States","lng":"-115.7526187","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/heavy-equipment-mechanic-3\/","zoom":19,"extra_fields":{"post_excerpt":"Heavy Equipment Mechanic&nbsp; Do you love mining? Do you think differently? Are you ready to define the future of this&hellip;","post_content":"<p style=\"color:#000000\"><strong><u>Heavy Equipment Mechanic&nbsp;<\/u><\/strong><\/p>\n<p style=\"color:#000000\"><span style=\"color:#333333\">Do you love mining? Do you think differently? Are you ready to define the future of this industry?<\/span><\/p>\n<p style=\"color:#000000\"><span style=\"color:#333333\">We\u2019ve been waiting for you! Turner Staffing&nbsp;Group is committed to changing the way mining companies do business. We develop our people. We partner with our clients. We believe in win, win, win.<\/span><\/p>\n<p>We are looking for a dynamic and talented professional to fill a Heavy Equipment Mechanic role at our fast-growing, forward thinking mining services company.<\/p>\n<p style=\"color:#000000\"><span style=\"color:#333333\">Turner Staffing&nbsp;Group is seeking an energetic professional who can leverage their Heavy Equipment knowledge to expand upon our fast-growing business, creating best practices for systems and scalable business processes to ensure profitable operations. This person will function as a Heavy Equipment Mechanic, willingness to do, learn, perform and improve any maintenance task. Tasks will be defined and evolve in all areas of mining operations to ensure preventative maintenance is practiced, repairs, equipment runs in the area of responsibility. You will report to and work with the Project Superintendent to develop heavy equipment procedures that will ensure safe operations. This is an opportunity to work as part of the operations team in a safe, productive, and fun environment.<\/span><\/p>\n<p style=\"color:#000000\"><strong><span style=\"color:#333333\">You<br><\/span><\/strong><span style=\"color:#333333\">You want to work for a services company that is rapidly changing the way the largest materials producers do business. You are motivated by solving problems and partnering with our clients and suppliers. You want to work with great people and enjoy being a part of a strong team. You are a knowledgeable Heavy Equipment Mechanic professional who is not afraid to jump into every detail. You want to be in a place where continuous learning and growth is the norm. You are adaptable and able to juggle multiple initiatives concurrently.<\/span><\/p>\n<p style=\"color:#000000\"><strong><span style=\"color:#333333\">Essential Skills &amp; Knowledge<\/span><\/strong><\/p>\n<p style=\"color:#000000\"><span style=\"color:#333333\">\u2022 Follow a consistent and regular schedule to perform various types of maintenance on heavy equipment and various pieces of machinery<\/span><\/p>\n<p style=\"color:#000000\"><span style=\"color:#333333\">\u2022 Perform repairs on equipment using tools, machine tools and measuring instruments<\/span><\/p>\n<p style=\"color:#000000\"><span style=\"color:#333333\">\u2022 Diagnose and troubleshoot fuel systems, electrical systems, hydraulic systems and propane systems<\/span><\/p>\n<p style=\"color:#000000\"><span style=\"color:#333333\">\u2022 Conduct oil changes, lubrication of equipment, tire replacements, hose repairs, battery replacements and assorted services<\/span><\/p>\n<p style=\"color:#000000\"><span style=\"color:#333333\">\u2022 Recondition and replace parts of the heavy equipment<\/span><\/p>\n<p style=\"color:#000000\"><span style=\"color:#333333\">\u2022 Operate and test equipment<\/span><\/p>\n<p style=\"color:#000000\"><span style=\"color:#333333\">\u2022 Diagnoses problem areas for any significant wear or tear on the equipment<\/span><\/p>\n<p style=\"color:#000000\"><span style=\"color:#333333\">\u2022 Produce detailed service reports and repair logs<\/span><\/p>\n<p style=\"color:#000000\"><span style=\"color:#333333\">\u2022 Follow all established procedures and protocols<\/span><\/p>\n<p style=\"color:#000000\"><span style=\"color:#333333\">\u2022 Build positive relationships with internal and external teams<\/span><\/p>\n<p style=\"color:#000000\"><span style=\"color:#333333\">\u2022 Perform additional duties as assigned<\/span><\/p>\n<p style=\"color:#000000\"><strong><span style=\"color:#333333\">Benefits<\/span><\/strong><\/p>\n<p style=\"color:#000000\"><span style=\"color:#333333\">Turner Staffing Group offers a competitive salary, an excellent work culture, career advancement opportunities. Our team offers a benefits program which includes Medical, Dental, Vision, Life, and a 401k with company match. We believe in a work life balance and established paid time off for major holidays.<\/span><\/p>\n<p style=\"color:#000000\"><span style=\"color:#333333\">At Turner Staffing Group, we encourage and celebrate an inclusive environment for all employees and are proud to be an equal opportunity workplace and affirmative action employer.<\/span><\/p>","post_title":"Heavy Equipment Mechanic","post_link":"https:\/\/turnerstaffing.com\/position\/heavy-equipment-mechanic-3\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"","%location_country%":"United States","%location_city%":"Elko","%location_state_id%":"NV","%location_state_name%":"Nevada","%location_city_state%":"Elko, NV","%education%":"","%department%":"","%description%":"<p style=\"color:#000000;\"><strong><u>Heavy Equipment Mechanic&nbsp;<\/u><\/strong><\/p>\n<p style=\"color:#000000;\"><span style=\"color:#333333;\">Do you love mining? Do you think differently? Are you ready to define the future of this industry?<\/span><\/p>\n<p style=\"color:#000000;\"><span style=\"color:#333333;\">We\u2019ve been waiting for you! Turner Staffing&nbsp;Group is committed to changing the way mining companies do business. We develop our people. We partner with our clients. We believe in win, win, win.<\/span><\/p>\n<p>We are looking for a dynamic and talented professional to fill a Heavy Equipment Mechanic role at our fast-growing, forward thinking mining services company.<\/p>\n<p style=\"color:#000000;\"><span style=\"color:#333333;\">Turner Staffing&nbsp;Group is seeking an energetic professional who can leverage their Heavy Equipment knowledge to expand upon our fast-growing business, creating best practices for systems and scalable business processes to ensure profitable operations. This person will function as a Heavy Equipment Mechanic, willingness to do, learn, perform and improve any maintenance task. Tasks will be defined and evolve in all areas of mining operations to ensure preventative maintenance is practiced, repairs, equipment runs in the area of responsibility. You will report to and work with the Project Superintendent to develop heavy equipment procedures that will ensure safe operations. This is an opportunity to work as part of the operations team in a safe, productive, and fun environment.<\/span><\/p>\n<p style=\"color:#000000;\"><strong><span style=\"color:#333333;\">You<br><\/span><\/strong><span style=\"color:#333333;\">You want to work for a services company that is rapidly changing the way the largest materials producers do business. You are motivated by solving problems and partnering with our clients and suppliers. You want to work with great people and enjoy being a part of a strong team. You are a knowledgeable Heavy Equipment Mechanic professional who is not afraid to jump into every detail. You want to be in a place where continuous learning and growth is the norm. You are adaptable and able to juggle multiple initiatives concurrently.<\/span><\/p>\n<p style=\"color:#000000;\"><strong><span style=\"color:#333333;\">Essential Skills &amp; Knowledge<\/span><\/strong><\/p>\n<p style=\"color:#000000;\"><span style=\"color:#333333;\">\u2022 Follow a consistent and regular schedule to perform various types of maintenance on heavy equipment and various pieces of machinery<\/span><\/p>\n<p style=\"color:#000000;\"><span style=\"color:#333333;\">\u2022 Perform repairs on equipment using tools, machine tools and measuring instruments<\/span><\/p>\n<p style=\"color:#000000;\"><span style=\"color:#333333;\">\u2022 Diagnose and troubleshoot fuel systems, electrical systems, hydraulic systems and propane systems<\/span><\/p>\n<p style=\"color:#000000;\"><span style=\"color:#333333;\">\u2022 Conduct oil changes, lubrication of equipment, tire replacements, hose repairs, battery replacements and assorted services<\/span><\/p>\n<p style=\"color:#000000;\"><span style=\"color:#333333;\">\u2022 Recondition and replace parts of the heavy equipment<\/span><\/p>\n<p style=\"color:#000000;\"><span style=\"color:#333333;\">\u2022 Operate and test equipment<\/span><\/p>\n<p style=\"color:#000000;\"><span style=\"color:#333333;\">\u2022 Diagnoses problem areas for any significant wear or tear on the equipment<\/span><\/p>\n<p style=\"color:#000000;\"><span style=\"color:#333333;\">\u2022 Produce detailed service reports and repair logs<\/span><\/p>\n<p style=\"color:#000000;\"><span style=\"color:#333333;\">\u2022 Follow all established procedures and protocols<\/span><\/p>\n<p style=\"color:#000000;\"><span style=\"color:#333333;\">\u2022 Build positive relationships with internal and external teams<\/span><\/p>\n<p style=\"color:#000000;\"><span style=\"color:#333333;\">\u2022 Perform additional duties as assigned<\/span><\/p>\n<p style=\"color:#000000;\"><strong><span style=\"color:#333333;\">Benefits<\/span><\/strong><\/p>\n<p style=\"color:#000000;\"><span style=\"color:#333333;\">Turner Staffing Group offers a competitive salary, an excellent work culture, career advancement opportunities. Our team offers a benefits program which includes Medical, Dental, Vision, Life, and a 401k with company match. We believe in a work life balance and established paid time off for major holidays.<\/span><\/p>\n<p style=\"color:#000000;\"><span style=\"color:#333333;\">At Turner Staffing Group, we encourage and celebrate an inclusive environment for all employees and are proud to be an equal opportunity workplace and affirmative action employer.<\/span><\/p>","%category%":"Operations","%breezy_id%":"812c4428ce1b","%breezy_friendly_id%":"812c4428ce1b-heavy-equipment-mechanic","%breezy_created_date%":"2023-03-09T17:38:02.991Z","%breezy_updated_date%":"2025-06-19T18:52:27.756Z","%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\"]"}}