Job Board

{"map_options":{"center_lat":"34.419837","center_lng":"-118.5627013","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":"Controller","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Controller\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Job Title: Controller Location: Santa Clarita, CA Reports To: President \/ Owner Overview We are seeking an experienced and highly&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/controller\/\" name=\"Controller\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Job Title: Controller Location: Santa Clarita, CA Reports To: President \/ Owner Overview We are seeking an experienced and highly&hellip;","address":"Valencia, CA, USA","location":{"lat":"34.419837","city":"Valencia","state":"CA","country":"United States","lng":"-118.5627013","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/controller\/","zoom":19,"extra_fields":{"post_excerpt":"Job Title: Controller Location: Santa Clarita, CA Reports To: President \/ Owner Overview We are seeking an experienced and highly&hellip;","post_content":"<p><strong>Job Title: Controller<\/strong><\/p>\n<p><strong>Location:<\/strong> Santa Clarita, CA<br>\n<strong>Reports To:<\/strong> President \/ Owner<\/p>\n<p><strong>Overview<\/strong><\/p>\n<p>We are seeking an experienced and highly self-sufficient Controller to oversee all accounting and financial functions for a growing heavy civil construction company. This is a department-of-one position\u2014ideal for a hands-on professional who thrives in both day-to-day accounting operations and strategic financial oversight. The Controller will lead financial reporting, job costing, forecasting, and compliance initiatives while completing an ongoing ERP migration and ensuring the company\u2019s continued financial strength.<\/p>\n<p><strong>Key Responsibilities<\/strong><\/p>\n<p><strong>Financial Reporting &amp; Month-End Close<\/strong><\/p>\n<ul>\n <li>Own and execute the full monthly close process,      including journal entries, reconciliations, accruals, and financial      statement preparation.<\/li>\n <li>Prepare and analyze income statements, balance      sheets, and cash flow reports.<\/li>\n <li>Maintain accurate general ledger accounts and ensure      GAAP compliance.<\/li>\n<\/ul>\n<p><strong>Job Costing &amp; Work in Progress (WIP)<\/strong><\/p>\n<ul>\n <li>Manage detailed job cost accounting across multiple      construction projects.<\/li>\n <li>Prepare WIP schedules and oversee      percentage-of-completion (POC) accounting.<\/li>\n <li>Partner with project managers and operations teams to      track budget-to-actual performance and identify cost trends.<\/li>\n<\/ul>\n<p><strong>Forecasting &amp; Financial Planning<\/strong><\/p>\n<ul>\n <li>Develop short- and long-term financial forecasts,      cash flow projections, and cost analyses.<\/li>\n <li>Support leadership with scenario modeling and      profitability assessments by project, division, and client.<\/li>\n<\/ul>\n<p><strong>ERP &amp; Systems Management<\/strong><\/p>\n<ul>\n <li>Lead the completion of the ERP migration and optimize      workflows post-implementation.<\/li>\n <li>Ensure data integrity, reporting accuracy, and      efficient use of the ERP system across accounting and operations.<\/li>\n<\/ul>\n<p><strong>Operational Accounting<\/strong><\/p>\n<ul>\n <li>Oversee accounts payable (AP), accounts receivable      (AR), payroll, and bank reconciliations.<\/li>\n <li>Manage vendor and subcontractor payments, lien      releases, and retention tracking.<\/li>\n <li>Handle company licensing, bonding, insurance      renewals, and compliance documentation.<\/li>\n<\/ul>\n<p><strong>Compliance &amp; Audit<\/strong><\/p>\n<ul>\n <li>Ensure compliance with federal, state, and local      regulations, including payroll tax filings and contractor licensing.<\/li>\n <li>Coordinate with external CPA firms for annual      financial reviews, audits, and tax filings.<\/li>\n<\/ul>\n<p><strong>Qualifications<\/strong><\/p>\n<ul>\n <li>Bachelor\u2019s degree in Accounting, Finance, or related      field <\/li>\n <li>3\u20137+ years of progressive accounting experience,      ideally within construction, heavy civil, or infrastructure sectors.<\/li>\n <li>Strong understanding of construction accounting, job      cost structures, and percentage-of-completion (POC) revenue recognition.<\/li>\n <li>Proven ability to manage month-end close,      forecasting, and WIP reporting independently.<\/li>\n <li>ERP implementation or migration experience (e.g.,      Viewpoint Vista, Foundation, CMiC, Sage 300, or similar).<\/li>\n <li>Advanced proficiency in Excel and familiarity with      project management and timekeeping systems.<\/li>\n <li>Strong organizational, analytical, and communication      skills.<\/li>\n<\/ul>\n<p><strong>Personality &amp; Work Style Fit<\/strong><\/p>\n<ul>\n <li>Hands-on and detail-oriented with strong      problem-solving instincts.<\/li>\n <li>Comfortable being a one-person accounting department      while partnering cross-functionally with project managers and leadership.<\/li>\n <li>Able to balance tactical work (AP, payroll,      reconciliations) with strategic oversight (forecasting, cost control,      financial planning).<\/li>\n<\/ul>\n<p><strong>Compensation &amp; Benefits<\/strong><\/p>\n<ul>\n <li>Competitive base salary commensurate with experience.<\/li>\n <li>PTO, holidays, and professional development support.<\/li>\n<\/ul>","post_title":"Controller","post_link":"https:\/\/turnerstaffing.com\/position\/controller\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"","%location_country%":"United States","%location_city%":"Valencia","%location_state_id%":"CA","%location_state_name%":"California","%location_city_state%":"Valencia, CA","%education%":"Bachelor's Degree","%department%":"","%description%":"<p><strong>Job Title: Controller<\/strong><\/p>\n<p><strong>Location:<\/strong> Santa Clarita, CA<br>\n<strong>Reports To:<\/strong> President \/ Owner<\/p>\n<p><strong>Overview<\/strong><\/p>\n<p>We are seeking an experienced and highly self-sufficient Controller to oversee all accounting and financial functions for a growing heavy civil construction company. This is a department-of-one position\u2014ideal for a hands-on professional who thrives in both day-to-day accounting operations and strategic financial oversight. The Controller will lead financial reporting, job costing, forecasting, and compliance initiatives while completing an ongoing ERP migration and ensuring the company\u2019s continued financial strength.<\/p>\n<p><strong>Key Responsibilities<\/strong><\/p>\n<p><strong>Financial Reporting &amp; Month-End Close<\/strong><\/p>\n<ul>\n <li>Own and execute the full monthly close process,      including journal entries, reconciliations, accruals, and financial      statement preparation.<\/li>\n <li>Prepare and analyze income statements, balance      sheets, and cash flow reports.<\/li>\n <li>Maintain accurate general ledger accounts and ensure      GAAP compliance.<\/li>\n<\/ul>\n<p><strong>Job Costing &amp; Work in Progress (WIP)<\/strong><\/p>\n<ul>\n <li>Manage detailed job cost accounting across multiple      construction projects.<\/li>\n <li>Prepare WIP schedules and oversee      percentage-of-completion (POC) accounting.<\/li>\n <li>Partner with project managers and operations teams to      track budget-to-actual performance and identify cost trends.<\/li>\n<\/ul>\n<p><strong>Forecasting &amp; Financial Planning<\/strong><\/p>\n<ul>\n <li>Develop short- and long-term financial forecasts,      cash flow projections, and cost analyses.<\/li>\n <li>Support leadership with scenario modeling and      profitability assessments by project, division, and client.<\/li>\n<\/ul>\n<p><strong>ERP &amp; Systems Management<\/strong><\/p>\n<ul>\n <li>Lead the completion of the ERP migration and optimize      workflows post-implementation.<\/li>\n <li>Ensure data integrity, reporting accuracy, and      efficient use of the ERP system across accounting and operations.<\/li>\n<\/ul>\n<p><strong>Operational Accounting<\/strong><\/p>\n<ul>\n <li>Oversee accounts payable (AP), accounts receivable      (AR), payroll, and bank reconciliations.<\/li>\n <li>Manage vendor and subcontractor payments, lien      releases, and retention tracking.<\/li>\n <li>Handle company licensing, bonding, insurance      renewals, and compliance documentation.<\/li>\n<\/ul>\n<p><strong>Compliance &amp; Audit<\/strong><\/p>\n<ul>\n <li>Ensure compliance with federal, state, and local      regulations, including payroll tax filings and contractor licensing.<\/li>\n <li>Coordinate with external CPA firms for annual      financial reviews, audits, and tax filings.<\/li>\n<\/ul>\n<p><strong>Qualifications<\/strong><\/p>\n<ul>\n <li>Bachelor\u2019s degree in Accounting, Finance, or related      field <\/li>\n <li>3\u20137+ years of progressive accounting experience,      ideally within construction, heavy civil, or infrastructure sectors.<\/li>\n <li>Strong understanding of construction accounting, job      cost structures, and percentage-of-completion (POC) revenue recognition.<\/li>\n <li>Proven ability to manage month-end close,      forecasting, and WIP reporting independently.<\/li>\n <li>ERP implementation or migration experience (e.g.,      Viewpoint Vista, Foundation, CMiC, Sage 300, or similar).<\/li>\n <li>Advanced proficiency in Excel and familiarity with      project management and timekeeping systems.<\/li>\n <li>Strong organizational, analytical, and communication      skills.<\/li>\n<\/ul>\n<p><strong>Personality &amp; Work Style Fit<\/strong><\/p>\n<ul>\n <li>Hands-on and detail-oriented with strong      problem-solving instincts.<\/li>\n <li>Comfortable being a one-person accounting department      while partnering cross-functionally with project managers and leadership.<\/li>\n <li>Able to balance tactical work (AP, payroll,      reconciliations) with strategic oversight (forecasting, cost control,      financial planning).<\/li>\n<\/ul>\n<p><strong>Compensation &amp; Benefits<\/strong><\/p>\n<ul>\n <li>Competitive base salary commensurate with experience.<\/li>\n <li>PTO, holidays, and professional development support.<\/li>\n<\/ul>","%category%":"Finance","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/81d5045f8bd1-controller","%breezy_id%":"81d5045f8bd1","%breezy_friendly_id%":"81d5045f8bd1-controller","%breezy_created_date%":"2025-10-24T16:42:56.404Z","%breezy_updated_date%":"2025-10-24T16:44:12.790Z","%_wpgmp_location_city%":"Valencia","%_wpgmp_location_state%":"CA","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Valencia, CA, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"34.419837","%_wpgmp_metabox_longitude%":"-118.5627013","%rank_math_internal_links_processed%":"1"}},"id":2836,"infowindow_disable":false},{"source":"post","title":"Communications Specialist","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Communications Specialist\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    About the Opportunity Turner Staffing Group is seeking an on-site, project-based (8-12 months)&nbsp;Communications Specialist to support our client&rsquo;s U.S. and&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/communications-specialist-2\/\" name=\"Communications Specialist\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"About the Opportunity Turner Staffing Group is seeking an on-site, project-based (8-12 months)&nbsp;Communications Specialist to support our client&rsquo;s U.S. and&hellip;","address":"Boron, CA, USA","location":{"lat":"34.9994202","city":"Boron","state":"CA","country":"United States","lng":"-117.6497822","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/communications-specialist-2\/","zoom":19,"extra_fields":{"post_excerpt":"About the Opportunity Turner Staffing Group is seeking an on-site, project-based (8-12 months)&nbsp;Communications Specialist to support our client&rsquo;s U.S. and&hellip;","post_content":"<p><strong>About the Opportunity<\/strong><\/p><p>Turner Staffing Group is seeking an on-site, project-based (8-12 months)&nbsp;<strong>Communications Specialist<\/strong> to support our client&rsquo;s U.S. and European operations in the industrial minerals sector. This hybrid strategic and hands-on role plays a key part in connecting people, strategy, and performance through compelling internal and external communications.<\/p><p>The Communications Specialist will lead communication initiatives, develop impactful content, and collaborate with senior leadership to ensure message alignment across multiple sites and functions. This is an exciting opportunity for an experienced communications professional who thrives in a dynamic, project-based environment.<\/p><p><strong>What You&rsquo;ll Do<\/strong><\/p><ul><li><p>Lead communication strategy and execution across U.S. and European operations.<\/p><\/li><li><p>Support operational and employee communications to drive engagement and alignment.<\/p><\/li><li><p>Elevate the internal and external brand through creative content and storytelling.<\/p><\/li><li><p>Draft and edit leadership messages, speeches, media materials, and presentations.<\/p><\/li><li><p>Manage communications for strategic projects (e.g., new products, sustainability initiatives, negotiations).<\/p><\/li><li><p>Coordinate and produce high-quality materials that connect employees to business priorities.<\/p><\/li><li><p>Partner with senior leadership to translate strategic goals into clear, actionable messages.<\/p><\/li><li><p>Support event planning, leadership meetings, and communication touchpoints.<\/p><\/li><li><p>Track communication effectiveness and employee feedback to support continuous improvement.<\/p><\/li><\/ul><p><strong>What You Bring<\/strong><\/p><ul><li><p>Bachelor&rsquo;s degree in Communications, Public Relations, Marketing, or a related field.<\/p><\/li><li><p>Proven experience designing and executing communications strategies in a corporate or industrial setting.<\/p><\/li><li><p>Excellent written and verbal communication skills with the ability to engage diverse audiences.<\/p><\/li><li><p>Proficiency in creating content across multiple platforms (print, digital, and social).<\/p><\/li><li><p>Strong interpersonal skills and ability to influence across teams and levels.<\/p><\/li><li><p>Highly organized, self-motivated, and able to manage multiple projects simultaneously.<\/p><\/li><li><p>Familiarity with project management or process improvement methodologies (Lean, Six Sigma, etc.) is a plus.<\/p><\/li><\/ul><p><strong>Why Apply<\/strong><\/p><ul><li><p>Opportunity to make a tangible impact in a high-visibility role.<\/p><\/li><li><p>Flexible schedule (25&ndash;40 hours per week).<\/p><\/li><li><p>Collaborative, mission-driven work environment.<\/p><\/li><li><p>Competitive hourly pay commensurate with experience.<\/p><\/li><\/ul>","post_title":"Communications Specialist","post_link":"https:\/\/turnerstaffing.com\/position\/communications-specialist-2\/","post_featured_image":"","post_categories":"","post_tags":"","%location_country%":"United States","%location_city%":"Boron","%location_state_id%":"CA","%location_city_state%":"Boron, CA","%description%":"<p><strong>About the Opportunity<\/strong><\/p><p>Turner Staffing Group is seeking an on-site, project-based (8-12 months)&nbsp;<strong>Communications Specialist<\/strong> to support our client&rsquo;s U.S. and European operations in the industrial minerals sector. This hybrid strategic and hands-on role plays a key part in connecting people, strategy, and performance through compelling internal and external communications.<\/p><p>The Communications Specialist will lead communication initiatives, develop impactful content, and collaborate with senior leadership to ensure message alignment across multiple sites and functions. This is an exciting opportunity for an experienced communications professional who thrives in a dynamic, project-based environment.<\/p><p><strong>What You&rsquo;ll Do<\/strong><\/p><ul><li><p>Lead communication strategy and execution across U.S. and European operations.<\/p><\/li><li><p>Support operational and employee communications to drive engagement and alignment.<\/p><\/li><li><p>Elevate the internal and external brand through creative content and storytelling.<\/p><\/li><li><p>Draft and edit leadership messages, speeches, media materials, and presentations.<\/p><\/li><li><p>Manage communications for strategic projects (e.g., new products, sustainability initiatives, negotiations).<\/p><\/li><li><p>Coordinate and produce high-quality materials that connect employees to business priorities.<\/p><\/li><li><p>Partner with senior leadership to translate strategic goals into clear, actionable messages.<\/p><\/li><li><p>Support event planning, leadership meetings, and communication touchpoints.<\/p><\/li><li><p>Track communication effectiveness and employee feedback to support continuous improvement.<\/p><\/li><\/ul><p><strong>What You Bring<\/strong><\/p><ul><li><p>Bachelor&rsquo;s degree in Communications, Public Relations, Marketing, or a related field.<\/p><\/li><li><p>Proven experience designing and executing communications strategies in a corporate or industrial setting.<\/p><\/li><li><p>Excellent written and verbal communication skills with the ability to engage diverse audiences.<\/p><\/li><li><p>Proficiency in creating content across multiple platforms (print, digital, and social).<\/p><\/li><li><p>Strong interpersonal skills and ability to influence across teams and levels.<\/p><\/li><li><p>Highly organized, self-motivated, and able to manage multiple projects simultaneously.<\/p><\/li><li><p>Familiarity with project management or process improvement methodologies (Lean, Six Sigma, etc.) is a plus.<\/p><\/li><\/ul><p><strong>Why Apply<\/strong><\/p><ul><li><p>Opportunity to make a tangible impact in a high-visibility role.<\/p><\/li><li><p>Flexible schedule (25&ndash;40 hours per week).<\/p><\/li><li><p>Collaborative, mission-driven work environment.<\/p><\/li><li><p>Competitive hourly pay commensurate with experience.<\/p><\/li><\/ul>","%application_url%":"https:\/\/jobs.crelate.com\/portal\/turnerstaffinggroup\/job\/csc7pzxnstdhep1sbjd54jer8a","%crelate_id%":"csc7pzxnstdhep1sbjd54jer8a","%crelate_created_date%":"2025-10-18T11:44:11.93Z","%crelate_updated_date%":"2025-10-26T14:05:44.35Z","%_wpgmp_location_city%":"Boron","%_wpgmp_location_state%":"CA","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Boron, CA, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"34.9994202","%_wpgmp_metabox_longitude%":"-117.6497822","%rank_math_internal_links_processed%":"1"}},"id":2832,"infowindow_disable":false},{"source":"post","title":"Communications Specialist","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Communications Specialist\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    About the Opportunity Turner Staffing Group is seeking an on-site, project-based (8-12 months)&nbsp;Communications Specialist&nbsp;to support our client\u2019s U.S. and European&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/communications-specialist\/\" name=\"Communications Specialist\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"About the Opportunity Turner Staffing Group is seeking an on-site, project-based (8-12 months)&nbsp;Communications Specialist&nbsp;to support our client\u2019s U.S. and European&hellip;","address":"Boron, CA, USA","location":{"lat":"34.9994202","city":"Boron","state":"CA","country":"United States","lng":"-117.6497822","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/communications-specialist\/","zoom":19,"extra_fields":{"post_excerpt":"About the Opportunity Turner Staffing Group is seeking an on-site, project-based (8-12 months)&nbsp;Communications Specialist&nbsp;to support our client\u2019s U.S. and European&hellip;","post_content":"<p><strong>About the Opportunity<\/strong><\/p>\n<p>Turner Staffing Group is seeking an on-site, project-based (8-12 months)&nbsp;<strong>Communications Specialist<\/strong>&nbsp;to support our client\u2019s U.S. and European operations in the industrial minerals sector. This hybrid strategic and hands-on role plays a key part in connecting people, strategy, and performance through compelling internal and external communications.<\/p>\n<p>The Communications Specialist will lead communication initiatives, develop impactful content, and collaborate with senior leadership to ensure message alignment across multiple sites and functions. This is an exciting opportunity for an experienced communications professional who thrives in a dynamic, project-based environment.<\/p>\n<p><strong>What You\u2019ll Do<\/strong><\/p>\n<ul><li>Lead communication strategy and execution across U.S. and European operations.<\/li><li>Support operational and employee communications to drive engagement and alignment.<\/li><li>Elevate the internal and external brand through creative content and storytelling.<\/li><li>Draft and edit leadership messages, speeches, media materials, and presentations.<\/li><li>Manage communications for strategic projects (e.g., new products, sustainability initiatives, negotiations).<\/li><li>Coordinate and produce high-quality materials that connect employees to business priorities.<\/li><li>Partner with senior leadership to translate strategic goals into clear, actionable messages.<\/li><li>Support event planning, leadership meetings, and communication touchpoints.<\/li><li>Track communication effectiveness and employee feedback to support continuous improvement.<\/li><\/ul>\n<p><strong>What You Bring<\/strong><\/p>\n<ul><li>Bachelor\u2019s degree in Communications, Public Relations, Marketing, or a related field.<\/li><li>Proven experience designing and executing communications strategies in a corporate or industrial setting.<\/li><li>Excellent written and verbal communication skills with the ability to engage diverse audiences.<\/li><li>Proficiency in creating content across multiple platforms (print, digital, and social).<\/li><li>Strong interpersonal skills and ability to influence across teams and levels.<\/li><li>Highly organized, self-motivated, and able to manage multiple projects simultaneously.<\/li><li>Familiarity with project management or process improvement methodologies (Lean, Six Sigma, etc.) is a plus.<\/li><\/ul>\n<p><strong>Why Apply<\/strong><\/p>\n<ul><li>Opportunity to make a tangible impact in a high-visibility role.<\/li><li>Flexible schedule (25\u201340 hours per week).<\/li><li>Collaborative, mission-driven work environment.<\/li><li>Competitive hourly pay commensurate with experience.<\/li><\/ul>","post_title":"Communications Specialist","post_link":"https:\/\/turnerstaffing.com\/position\/communications-specialist\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"","%location_country%":"United States","%location_city%":"Boron","%location_state_id%":"CA","%location_state_name%":"California","%location_city_state%":"Boron, CA","%education%":"","%department%":"","%description%":"<p><strong>About the Opportunity<\/strong><\/p>\n<p>Turner Staffing Group is seeking an on-site, project-based (8-12 months)&nbsp;<strong>Communications Specialist<\/strong>&nbsp;to support our client\u2019s U.S. and European operations in the industrial minerals sector. This hybrid strategic and hands-on role plays a key part in connecting people, strategy, and performance through compelling internal and external communications.<\/p>\n<p>The Communications Specialist will lead communication initiatives, develop impactful content, and collaborate with senior leadership to ensure message alignment across multiple sites and functions. This is an exciting opportunity for an experienced communications professional who thrives in a dynamic, project-based environment.<\/p>\n<p><strong>What You\u2019ll Do<\/strong><\/p>\n<ul><li>Lead communication strategy and execution across U.S. and European operations.<\/li><li>Support operational and employee communications to drive engagement and alignment.<\/li><li>Elevate the internal and external brand through creative content and storytelling.<\/li><li>Draft and edit leadership messages, speeches, media materials, and presentations.<\/li><li>Manage communications for strategic projects (e.g., new products, sustainability initiatives, negotiations).<\/li><li>Coordinate and produce high-quality materials that connect employees to business priorities.<\/li><li>Partner with senior leadership to translate strategic goals into clear, actionable messages.<\/li><li>Support event planning, leadership meetings, and communication touchpoints.<\/li><li>Track communication effectiveness and employee feedback to support continuous improvement.<\/li><\/ul>\n<p><strong>What You Bring<\/strong><\/p>\n<ul><li>Bachelor\u2019s degree in Communications, Public Relations, Marketing, or a related field.<\/li><li>Proven experience designing and executing communications strategies in a corporate or industrial setting.<\/li><li>Excellent written and verbal communication skills with the ability to engage diverse audiences.<\/li><li>Proficiency in creating content across multiple platforms (print, digital, and social).<\/li><li>Strong interpersonal skills and ability to influence across teams and levels.<\/li><li>Highly organized, self-motivated, and able to manage multiple projects simultaneously.<\/li><li>Familiarity with project management or process improvement methodologies (Lean, Six Sigma, etc.) is a plus.<\/li><\/ul>\n<p><strong>Why Apply<\/strong><\/p>\n<ul><li>Opportunity to make a tangible impact in a high-visibility role.<\/li><li>Flexible schedule (25\u201340 hours per week).<\/li><li>Collaborative, mission-driven work environment.<\/li><li>Competitive hourly pay commensurate with experience.<\/li><\/ul>","%category%":"","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/59fc91db740e-communications-specialist","%breezy_id%":"59fc91db740e","%breezy_friendly_id%":"59fc91db740e-communications-specialist","%breezy_created_date%":"2025-10-21T14:15:51.786Z","%breezy_updated_date%":"2025-10-21T14:16:24.393Z","%_wpgmp_location_city%":"Boron","%_wpgmp_location_state%":"CA","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Boron, CA, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"34.9994202","%_wpgmp_metabox_longitude%":"-117.6497822","%rank_math_internal_links_processed%":"1"}},"id":2831,"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-8\/\" 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":"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\/excavator-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":"Excavator Operator","post_link":"https:\/\/turnerstaffing.com\/position\/excavator-operator-8\/","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%":"","%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%":"Other","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/2e80afdf7847-excavator-operator","%breezy_id%":"2e80afdf7847","%breezy_friendly_id%":"2e80afdf7847-excavator-operator","%breezy_created_date%":"2025-10-16T12:45:20.350Z","%breezy_updated_date%":"2025-10-16T13:05:26.206Z","%_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":2829,"infowindow_disable":false},{"source":"post","title":"Director of Maintenance","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Director of Maintenance\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Director of Maintenance Reports to VP of Operations Reporting to the VP of Operations, the Director of Maintenance is responsible&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/director-of-maintenance\/\" name=\"Director of Maintenance\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Director of Maintenance Reports to VP of Operations Reporting to the VP of Operations, the Director of Maintenance is responsible&hellip;","address":"Bloomington, IN, USA","location":{"lat":"39.169574","city":"Bloomington","state":"IN","country":"United States","lng":"-86.5385549","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/director-of-maintenance\/","zoom":19,"extra_fields":{"post_excerpt":"Director of Maintenance Reports to VP of Operations Reporting to the VP of Operations, the Director of Maintenance is responsible&hellip;","post_content":"<p><strong><u>Director of Maintenance<\/u><\/strong><\/p>\n<p><strong>Reports to VP of Operations<\/strong><\/p>\n<p>Reporting to the VP of Operations, the Director of Maintenance is responsible for developing and executing the company\u2019s equipment maintenance philosophy, leading the corporate maintenance function, and ensuring operational readiness across all sites. This role builds the systems, processes, and standards that define how Turner Mining Group maintains and manages its heavy equipment fleet.<\/p>\n<p>The position drives the strategy for corrective maintenance and breakdown response, backlog management, preventive maintenance, reliability improvement, planning and scheduling, and cost control, ensuring that every site operates within a structured, measurable framework. It also leads corporate maintenance initiatives, mentors site-level leaders and ensures consistency and excellence in execution.<\/p>\n<p>The Director of Maintenance provides visibility to senior leadership on equipment performance, maintenance cost trends, and emerging reliability issues. Through data-driven insights and field collaboration, this position ensures that maintenance supports both production goals and long-term asset value.<\/p>\n<p><strong><u>Position Responsibilities:<\/u><\/strong><\/p>\n<p><strong>Maintenance Strategy and Program Development<\/strong><\/p>\n<p>\u2022 Define the corporate maintenance philosophy and translate it into standard programs and procedures.<\/p>\n<p>\u2022 Design and implement a comprehensive preventive and predictive maintenance system across all sites.<\/p>\n<p>\u2022 Develop the corporate maintenance manual, standard work, and documentation to guide all levels of the organization.<\/p>\n<p>\u2022 Establish baseline expectations for equipment reliability, availability, and utilization.<\/p>\n<p>\u2022 Create maintenance readiness templates and tools to deploy at new operations.<\/p>\n<p>\u2022 Identify opportunities for improvement through equipment performance data and field feedback.<\/p>\n<p>\u2022 Integrate planning, scheduling, and backlog management as standard practices across the fleet.<\/p>\n<p><strong>Corporate Leadership and Site Support<\/strong><\/p>\n<p>\u2022 Lead the corporate maintenance team, ensuring alignment with company goals and operational priorities.<\/p>\n<p>\u2022 Provide guidance and mentorship to site-level maintenance superintendents and execution teams.<\/p>\n<p>\u2022 Support site leaders in building localized systems for work management, preventive maintenance, and parts control.<\/p>\n<p>\u2022 Develop and deploy maintenance training, operator care programs, and technician development initiatives.<\/p>\n<p>\u2022 Coordinate maintenance planning and reliability reviews with site operations and technical services.<\/p>\n<p><strong>Financial Control and Procurement<\/strong><\/p>\n<p>\u2022 Oversee maintenance cost control across all operations, ensuring accuracy and accountability in budgets.<\/p>\n<p>\u2022 Develop cost models for repair vs. replacement decisions and support capital planning.<\/p>\n<p>\u2022 Manage corporate procurement of parts, service, and repair contracts to ensure best value and quality.<\/p>\n<p>\u2022 Standardize vendor management processes and develop preferred supplier relationships.<\/p>\n<p>\u2022 Review parts inventories, usage rates, and critical spares management to minimize downtime.<\/p>\n<p><strong>Fleet Performance and Reporting<\/strong><\/p>\n<p>\u2022 Monitor fleet performance metrics (availability, utilization, mean time between failures, cost per hour).<\/p>\n<p>\u2022 Build dashboards and reporting tools to track equipment condition, maintenance backlog, and cost trends.<\/p>\n<p>\u2022 Conduct monthly maintenance reviews with site leadership and report performance to the VP of Operations.<\/p>\n<p>\u2022 Lead root cause analysis on major failures and implement corrective action plans.<\/p>\n<p>\u2022 Maintain visibility over warranty claims, component rebuild programs, and reliability improvement projects.<\/p>\n<p><strong>Continuous Improvement and Systems Development<\/strong><\/p>\n<p>\u2022 Evaluate and implement CMMS, telematics, and diagnostic systems to improve data accuracy and workflow efficiency.<\/p>\n<p>\u2022 Champion continuous improvement in maintenance practices through data analysis and lessons learned.<\/p>\n<p>\u2022 Benchmark performance against industry standards and integrate best practices from OEMs and peers.<\/p>\n<p>\u2022 Collaborate with operations, safety, and technical services to ensure maintenance strategies support production goals and regulatory compliance.<\/p>\n<p><strong><u>The Ideal Candidate:<\/u><\/strong><\/p>\n<p><strong>Knowledge<\/strong><\/p>\n<p>\u2022 Degree or technical certification in Mechanical Engineering, Maintenance Management, or related field<\/p>\n<p>\u2022 10+ years of heavy equipment maintenance experience, preferably in mining<\/p>\n<p>\u2022 Proven background in fleet management, reliability, and preventive maintenance systems<\/p>\n<p>\u2022 Strong understanding of cost control, budgeting, and parts procurement<\/p>\n<p>\u2022 Proficiency in CMMS systems, telematics data, and maintenance analytics tools<\/p>\n<p><strong>Key Competencies \/ Skills<\/strong><\/p>\n<p>\u2022 Strategic thinker with strong organizational and leadership skills<\/p>\n<p>\u2022 Able to translate complex technical issues into clear business impact<\/p>\n<p>\u2022 Results-oriented with strong accountability for performance<\/p>\n<p>\u2022 Skilled in developing systems and processes from concept to field execution<\/p>\n<p>\u2022 Data-driven decision maker with solid financial acumen<\/p>\n<p>\u2022 Excellent communicator and mentor across diverse teams<\/p>","post_title":"Director of Maintenance","post_link":"https:\/\/turnerstaffing.com\/position\/director-of-maintenance\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Senior","%location_country%":"United States","%location_city%":"Bloomington","%location_state_id%":"IN","%location_state_name%":"Indiana","%location_city_state%":"Bloomington, IN","%education%":"Unspecified","%department%":"Maintenance","%description%":"<p><strong><u>Director of Maintenance<\/u><\/strong><\/p>\n<p><strong>Reports to VP of Operations<\/strong><\/p>\n<p>Reporting to the VP of Operations, the Director of Maintenance is responsible for developing and executing the company\u2019s equipment maintenance philosophy, leading the corporate maintenance function, and ensuring operational readiness across all sites. This role builds the systems, processes, and standards that define how Turner Mining Group maintains and manages its heavy equipment fleet.<\/p>\n<p>The position drives the strategy for corrective maintenance and breakdown response, backlog management, preventive maintenance, reliability improvement, planning and scheduling, and cost control, ensuring that every site operates within a structured, measurable framework. It also leads corporate maintenance initiatives, mentors site-level leaders and ensures consistency and excellence in execution.<\/p>\n<p>The Director of Maintenance provides visibility to senior leadership on equipment performance, maintenance cost trends, and emerging reliability issues. Through data-driven insights and field collaboration, this position ensures that maintenance supports both production goals and long-term asset value.<\/p>\n<p><strong><u>Position Responsibilities:<\/u><\/strong><\/p>\n<p><strong>Maintenance Strategy and Program Development<\/strong><\/p>\n<p>\u2022 Define the corporate maintenance philosophy and translate it into standard programs and procedures.<\/p>\n<p>\u2022 Design and implement a comprehensive preventive and predictive maintenance system across all sites.<\/p>\n<p>\u2022 Develop the corporate maintenance manual, standard work, and documentation to guide all levels of the organization.<\/p>\n<p>\u2022 Establish baseline expectations for equipment reliability, availability, and utilization.<\/p>\n<p>\u2022 Create maintenance readiness templates and tools to deploy at new operations.<\/p>\n<p>\u2022 Identify opportunities for improvement through equipment performance data and field feedback.<\/p>\n<p>\u2022 Integrate planning, scheduling, and backlog management as standard practices across the fleet.<\/p>\n<p><strong>Corporate Leadership and Site Support<\/strong><\/p>\n<p>\u2022 Lead the corporate maintenance team, ensuring alignment with company goals and operational priorities.<\/p>\n<p>\u2022 Provide guidance and mentorship to site-level maintenance superintendents and execution teams.<\/p>\n<p>\u2022 Support site leaders in building localized systems for work management, preventive maintenance, and parts control.<\/p>\n<p>\u2022 Develop and deploy maintenance training, operator care programs, and technician development initiatives.<\/p>\n<p>\u2022 Coordinate maintenance planning and reliability reviews with site operations and technical services.<\/p>\n<p><strong>Financial Control and Procurement<\/strong><\/p>\n<p>\u2022 Oversee maintenance cost control across all operations, ensuring accuracy and accountability in budgets.<\/p>\n<p>\u2022 Develop cost models for repair vs. replacement decisions and support capital planning.<\/p>\n<p>\u2022 Manage corporate procurement of parts, service, and repair contracts to ensure best value and quality.<\/p>\n<p>\u2022 Standardize vendor management processes and develop preferred supplier relationships.<\/p>\n<p>\u2022 Review parts inventories, usage rates, and critical spares management to minimize downtime.<\/p>\n<p><strong>Fleet Performance and Reporting<\/strong><\/p>\n<p>\u2022 Monitor fleet performance metrics (availability, utilization, mean time between failures, cost per hour).<\/p>\n<p>\u2022 Build dashboards and reporting tools to track equipment condition, maintenance backlog, and cost trends.<\/p>\n<p>\u2022 Conduct monthly maintenance reviews with site leadership and report performance to the VP of Operations.<\/p>\n<p>\u2022 Lead root cause analysis on major failures and implement corrective action plans.<\/p>\n<p>\u2022 Maintain visibility over warranty claims, component rebuild programs, and reliability improvement projects.<\/p>\n<p><strong>Continuous Improvement and Systems Development<\/strong><\/p>\n<p>\u2022 Evaluate and implement CMMS, telematics, and diagnostic systems to improve data accuracy and workflow efficiency.<\/p>\n<p>\u2022 Champion continuous improvement in maintenance practices through data analysis and lessons learned.<\/p>\n<p>\u2022 Benchmark performance against industry standards and integrate best practices from OEMs and peers.<\/p>\n<p>\u2022 Collaborate with operations, safety, and technical services to ensure maintenance strategies support production goals and regulatory compliance.<\/p>\n<p><strong><u>The Ideal Candidate:<\/u><\/strong><\/p>\n<p><strong>Knowledge<\/strong><\/p>\n<p>\u2022 Degree or technical certification in Mechanical Engineering, Maintenance Management, or related field<\/p>\n<p>\u2022 10+ years of heavy equipment maintenance experience, preferably in mining<\/p>\n<p>\u2022 Proven background in fleet management, reliability, and preventive maintenance systems<\/p>\n<p>\u2022 Strong understanding of cost control, budgeting, and parts procurement<\/p>\n<p>\u2022 Proficiency in CMMS systems, telematics data, and maintenance analytics tools<\/p>\n<p><strong>Key Competencies \/ Skills<\/strong><\/p>\n<p>\u2022 Strategic thinker with strong organizational and leadership skills<\/p>\n<p>\u2022 Able to translate complex technical issues into clear business impact<\/p>\n<p>\u2022 Results-oriented with strong accountability for performance<\/p>\n<p>\u2022 Skilled in developing systems and processes from concept to field execution<\/p>\n<p>\u2022 Data-driven decision maker with solid financial acumen<\/p>\n<p>\u2022 Excellent communicator and mentor across diverse teams<\/p>","%category%":"Management","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/fbe030913c67-director-of-maintenance","%breezy_id%":"fbe030913c67","%breezy_friendly_id%":"fbe030913c67-director-of-maintenance","%breezy_created_date%":"2025-10-16T13:46:22.579Z","%breezy_updated_date%":"2025-10-17T14:11:52.644Z","%_wpgmp_location_city%":"Bloomington","%_wpgmp_location_state%":"IN","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Bloomington, IN, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"39.169574","%_wpgmp_metabox_longitude%":"-86.5385549","%rank_math_internal_links_processed%":"1"}},"id":2830,"infowindow_disable":false},{"source":"post","title":"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 Do you love mining? Do you think differently? Are you ready to define&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/excavator-operator-mining-2\/\" 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 Do you love mining? Do you think differently? Are you ready to define&hellip;","address":"Kermit, TX, USA","location":{"lat":"31.8576265","city":"Kermit","state":"TX","country":"United States","lng":"-103.0926652","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/excavator-operator-mining-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 style=\"color:#000000\"><strong><span style=\"text-decoration:underline\"><span style=\"color:#555555\">Turner Mining Group \u2013 Heavy Equipment Operator<\/span><\/span><\/strong><\/p>\n<p style=\"color:#000000\"><span style=\"color:#333333\">Do you love mining? Do you think differently? Are you ready to define the future of this industry?<\/span><\/p>\n<p style=\"color:#000000\"><span style=\"color:#333333\">We\u2019ve been waiting for you! Turner Mining Group is committed to changing the way mining companies do business. We develop our people. We partner with our clients. We believe in win, win, win.<\/span><\/p>\n<p style=\"color:#000000\"><span style=\"color:#333333\">We are looking for a dynamic and talented mining Heavy Equipment Operators for our fast-growing, forward thinking mining services company headquartered in Bloomington, Indiana with our Operations team headquartered in Salt Lake City, Utah.<\/span><\/p>\n<p style=\"color:#000000\"><span style=\"color:#333333\">Turner Mining Group is seeking an energetic mining professionals who can leverage their mining knowledge to expand upon our fast-growing business, creating best practices for equipment operations to ensure profitable operations.<\/span><\/p>\n<p style=\"color:#000000\"><strong><span style=\"color:#333333\">You<\/span><\/strong><\/p>\n<p style=\"color:#000000\"><span style=\"color:#333333\">You want to work for a services company that is rapidly changing the way the largest materials producers do business. You are motivated by solving problems and partnering with our clients and suppliers. You want to work with great people and enjoy being a part of a strong team. You are a knowledgeable Operator who is not afraid to jump into every detail. You want to be in a place where continuous learning and growth is the norm. You are adaptable and able to juggle multiple initiatives concurrently.<\/span><\/p>\n<p style=\"color:#000000\"><strong><span style=\"color:#555555\">Responsibilities:<\/span><\/strong><\/p>\n<ul><li>Operating heavy equipment including blade, excavators, dozers, haul trucks, and other machines<\/li><li>Performing all pre-shift inspections, some basic maintenance and upkeep<\/li><li>Working with teammates on crew to maximize production while always maintaining our safety rules and regulations.<\/li><\/ul>\n<p style=\"color:#000000\"><strong>Requirements:<\/strong><\/p>\n<ul><li><span style=\"color:#555555\">Safety oriented, awareness of everyone and everything that is around you<\/span><\/li><li><span style=\"color:#555555\">Strong work ethic<\/span><\/li><li><span style=\"color:#555555\">Willingness to learn<\/span><\/li><li><span style=\"color:#555555\">Ability to be flexible and to adapt<\/span><\/li><li><span style=\"color:#555555\">Experience with heavy equipment<\/span><\/li><li><span style=\"color:#555555\">Preferred to have MSHA training<\/span><\/li><\/ul>\n<p><strong>Benefits:<\/strong><\/p>\n<ul><p style=\"color:#000000\"><span style=\"color:#333333\">Turner Mining Group offers a competitive salary, an excellent work culture, career advancement opportunities. Our team offers a benefits program which includes Medical, Dental, Vision, Life, and a 401k with company match.<\/span><\/p><p style=\"color:#000000\"><span style=\"color:#333333\">At Turner Mining Group, we encourage and celebrate an inclusive environment for all employees and are proud to be an equal opportunity workplace and affirmative action employer.<\/span><\/p><\/ul>\n<p><\/p>","post_title":"Excavator Operator &#8211; Mining","post_link":"https:\/\/turnerstaffing.com\/position\/excavator-operator-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:#000000;\"><strong><span style=\"text-decoration:underline;\"><span style=\"color:#555555;\">Turner Mining Group \u2013 Heavy Equipment Operator<\/span><\/span><\/strong><\/p>\n<p style=\"color:#000000;\"><span style=\"color:#333333;\">Do you love mining? Do you think differently? Are you ready to define the future of this industry?<\/span><\/p>\n<p style=\"color:#000000;\"><span style=\"color:#333333;\">We\u2019ve been waiting for you! Turner Mining Group is committed to changing the way mining companies do business. We develop our people. We partner with our clients. We believe in win, win, win.<\/span><\/p>\n<p style=\"color:#000000;\"><span style=\"color:#333333;\">We are looking for a dynamic and talented mining Heavy Equipment Operators for our fast-growing, forward thinking mining services company headquartered in Bloomington, Indiana with our Operations team headquartered in Salt Lake City, Utah.<\/span><\/p>\n<p style=\"color:#000000;\"><span style=\"color:#333333;\">Turner Mining Group is seeking an energetic mining professionals who can leverage their mining knowledge to expand upon our fast-growing business, creating best practices for equipment operations to ensure profitable operations.<\/span><\/p>\n<p style=\"color:#000000;\"><strong><span style=\"color:#333333;\">You<\/span><\/strong><\/p>\n<p style=\"color:#000000;\"><span style=\"color:#333333;\">You want to work for a services company that is rapidly changing the way the largest materials producers do business. You are motivated by solving problems and partnering with our clients and suppliers. You want to work with great people and enjoy being a part of a strong team. You are a knowledgeable Operator who is not afraid to jump into every detail. You want to be in a place where continuous learning and growth is the norm. You are adaptable and able to juggle multiple initiatives concurrently.<\/span><\/p>\n<p style=\"color:#000000;\"><strong><span style=\"color:#555555;\">Responsibilities:<\/span><\/strong><\/p>\n<ul><li>Operating heavy equipment including blade, excavators, dozers, haul trucks, and other machines<\/li><li>Performing all pre-shift inspections, some basic maintenance and upkeep<\/li><li>Working with teammates on crew to maximize production while always maintaining our safety rules and regulations.<\/li><\/ul>\n<p style=\"color:#000000;\"><strong>Requirements:<\/strong><\/p>\n<ul><li><span style=\"color:#555555;\">Safety oriented, awareness of everyone and everything that is around you<\/span><\/li><li><span style=\"color:#555555;\">Strong work ethic<\/span><\/li><li><span style=\"color:#555555;\">Willingness to learn<\/span><\/li><li><span style=\"color:#555555;\">Ability to be flexible and to adapt<\/span><\/li><li><span style=\"color:#555555;\">Experience with heavy equipment<\/span><\/li><li><span style=\"color:#555555;\">Preferred to have MSHA training<\/span><\/li><\/ul>\n<p><strong>Benefits:<\/strong><\/p>\n<ul><p style=\"color:#000000;\"><span style=\"color:#333333;\">Turner Mining Group offers a competitive salary, an excellent work culture, career advancement opportunities. Our team offers a benefits program which includes Medical, Dental, Vision, Life, and a 401k with company match.<\/span><\/p><p style=\"color:#000000;\"><span style=\"color:#333333;\">At Turner Mining Group, we encourage and celebrate an inclusive environment for all employees and are proud to be an equal opportunity workplace and affirmative action employer.<\/span><\/p><\/ul>\n<p><\/p>","%category%":"","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/46ef755ebcf0-excavator-operator-mining","%breezy_id%":"46ef755ebcf0","%breezy_friendly_id%":"46ef755ebcf0-excavator-operator-mining","%breezy_created_date%":"2022-10-06T13:11:38.270Z","%breezy_updated_date%":"2025-10-15T19:09:11.167Z","%_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":2828,"infowindow_disable":false},{"source":"post","title":"Equipment &amp; Safety Training Specialist","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Equipment &amp; Safety Training Specialist\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    The Trainer helps new and current construction employees build the skills they need to work safely, efficiently, and grow within&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/equipment-safety-training-specialist\/\" name=\"Equipment &amp; Safety Training Specialist\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"The Trainer helps new and current construction employees build the skills they need to work safely, efficiently, and grow within&hellip;","address":"Bowmansville, PA, USA","location":{"lat":"40.1967609","city":"Bowmansville","state":"PA","country":"United States","lng":"-76.0174416","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/equipment-safety-training-specialist\/","zoom":19,"extra_fields":{"post_excerpt":"The Trainer helps new and current construction employees build the skills they need to work safely, efficiently, and grow within&hellip;","post_content":"<p>The Trainer helps new and current construction employees build the skills they need to work <\/p>\n<p>safely, efficiently, and grow within the company. This role provides hands-on and classroom <\/p>\n<p>training for supervisors, operators and laborers, supports career development, and promotes <\/p>\n<p>proper equipment use to reduce costs and improve jobsite performance.<\/p>\n<p>ESSENTIAL DUTIES AND RESPONSIBILITIES:<\/p>\n<p>Include the following. Other duties may be assigned.<\/p>\n<p>\u2022 Train new and existing employees on equipment operation, safety, and best practices.<\/p>\n<p>\u2022 Assess skills and provide customized training to improve performance.<\/p>\n<p>\u2022 Help with hiring and promotion by evaluating operator and laborer abilities.<\/p>\n<p>\u2022 Create and lead classroom, field, and online training sessions.<\/p>\n<p>\u2022 Manage the Operator Certification Program, including testing and field follow-up.<\/p>\n<p>\u2022 Work closely with field employees and supervisors to support development.<\/p>\n<p>\u2022 Promote and teach safe work practices; participate on the Safety Committee.<\/p>\n<p>\u2022 Understand company equipment, its safe and efficient use, and how to prevent damage <\/p>\n<p>or misuse.<\/p>\n<p>\u2022 Stays ahead of industry trends by using technology to enhance training and anticipate <\/p>\n<p>future needs<\/p>\n<p>\u2022 Ability to tailor communication and training methods to suit different audiences, <\/p>\n<p>ensuring information is delivered in the most effective format.<\/p>\n<p>\u2022 Builds strong relationships and develops peer leaders to extend the reach and impact of <\/p>\n<p>training throughout the organization.<\/p>\n<p>EDUCATION and\/or EXPERIENCE:<\/p>\n<p>\u2022 Experience productively and safely operating various heavy equipment in construction.<\/p>\n<p>\u2022 Strong understanding of earthmoving and construction practices.<\/p>\n<p>\u2022 Skilled in teaching and coaching employees of different experience levels.<\/p>\n<p>\u2022 Clear communicator, both in writing and in person.<\/p>\n<p>\u2022 Patient, professional, and a team player.<\/p>\n<p>\u2022 Self-motivated with strong problem-solving and people skills.<\/p>\n<p>\u2022 Able to recognize and develop employee strengths to help them succeed.<\/p>\n<p>\u2022 Strong public speaking and presentation skills, with experience delivering training to <\/p>\n<p>groups of various sizes in both classroom and field settings.<\/p>","post_title":"Equipment &amp; Safety Training Specialist","post_link":"https:\/\/turnerstaffing.com\/position\/equipment-safety-training-specialist\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"","%location_country%":"United States","%location_city%":"Bowmansville","%location_state_id%":"PA","%location_state_name%":"Pennsylvania","%location_city_state%":"Bowmansville, PA","%education%":"","%department%":"","%description%":"<p>The Trainer helps new and current construction employees build the skills they need to work <\/p>\n<p>safely, efficiently, and grow within the company. This role provides hands-on and classroom <\/p>\n<p>training for supervisors, operators and laborers, supports career development, and promotes <\/p>\n<p>proper equipment use to reduce costs and improve jobsite performance.<\/p>\n<p>ESSENTIAL DUTIES AND RESPONSIBILITIES:<\/p>\n<p>Include the following. Other duties may be assigned.<\/p>\n<p>\u2022 Train new and existing employees on equipment operation, safety, and best practices.<\/p>\n<p>\u2022 Assess skills and provide customized training to improve performance.<\/p>\n<p>\u2022 Help with hiring and promotion by evaluating operator and laborer abilities.<\/p>\n<p>\u2022 Create and lead classroom, field, and online training sessions.<\/p>\n<p>\u2022 Manage the Operator Certification Program, including testing and field follow-up.<\/p>\n<p>\u2022 Work closely with field employees and supervisors to support development.<\/p>\n<p>\u2022 Promote and teach safe work practices; participate on the Safety Committee.<\/p>\n<p>\u2022 Understand company equipment, its safe and efficient use, and how to prevent damage <\/p>\n<p>or misuse.<\/p>\n<p>\u2022 Stays ahead of industry trends by using technology to enhance training and anticipate <\/p>\n<p>future needs<\/p>\n<p>\u2022 Ability to tailor communication and training methods to suit different audiences, <\/p>\n<p>ensuring information is delivered in the most effective format.<\/p>\n<p>\u2022 Builds strong relationships and develops peer leaders to extend the reach and impact of <\/p>\n<p>training throughout the organization.<\/p>\n<p>EDUCATION and\/or EXPERIENCE:<\/p>\n<p>\u2022 Experience productively and safely operating various heavy equipment in construction.<\/p>\n<p>\u2022 Strong understanding of earthmoving and construction practices.<\/p>\n<p>\u2022 Skilled in teaching and coaching employees of different experience levels.<\/p>\n<p>\u2022 Clear communicator, both in writing and in person.<\/p>\n<p>\u2022 Patient, professional, and a team player.<\/p>\n<p>\u2022 Self-motivated with strong problem-solving and people skills.<\/p>\n<p>\u2022 Able to recognize and develop employee strengths to help them succeed.<\/p>\n<p>\u2022 Strong public speaking and presentation skills, with experience delivering training to <\/p>\n<p>groups of various sizes in both classroom and field settings.<\/p>","%category%":"Operations","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/ce7f98ceee69-equipment-safety-training-specialist","%breezy_id%":"ce7f98ceee69","%breezy_friendly_id%":"ce7f98ceee69-equipment-safety-training-specialist","%breezy_created_date%":"2025-10-14T20:45:02.280Z","%breezy_updated_date%":"2025-10-14T20:46:51.395Z","%_wpgmp_location_city%":"Bowmansville","%_wpgmp_location_state%":"PA","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Bowmansville, PA, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"40.1967609","%_wpgmp_metabox_longitude%":"-76.0174416","%rank_math_internal_links_processed%":"1"}},"id":2827,"infowindow_disable":false},{"source":"post","title":"Project Engineer &#8211; Mining","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Project Engineer &#8211; Mining\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Project Engineer Advisor to Project Management Reports to Project Manager Reporting to the Project Manager, the Project Engineer plays a&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/project-engineer-mining-3\/\" name=\"Project Engineer &#8211; Mining\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Project Engineer Advisor to Project Management Reports to Project Manager Reporting to the Project Manager, the Project Engineer plays a&hellip;","address":"Ely, NV, USA","location":{"lat":"39.2533328","city":"Ely","state":"NV","country":"United States","lng":"-114.874248","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/project-engineer-mining-3\/","zoom":19,"extra_fields":{"post_excerpt":"Project Engineer Advisor to Project Management Reports to Project Manager Reporting to the Project Manager, the Project Engineer plays a&hellip;","post_content":"<p><strong><u>Project Engineer<\/u><\/strong><\/p>\n<p><strong>Advisor to Project Management<\/strong><\/p>\n<p><strong>Reports to Project Manager<\/strong><\/p>\n<p>Reporting to the Project Manager, the Project Engineer plays a crucial role in bridging technical mining expertise with mining operations by providing insights through engineering guidance, driving operational efficiency, financial accountability, and long-term project success. This position is responsible for analyzing operational data, preparing engineering designs\/operational GPS support, conducting field data collection, and production forecasting.<\/p>\n<p>By integrating engineering principles, the role provides support for optimizing mining operations, identifying cost-saving opportunities, and evaluating potential efficiency improvements. Additionally, it involves collaboration with Turner Mining Group and client teams, ensuring alignment between corporate objectives, site-level execution, and regulatory compliance.<\/p>\n<p>This role requires a strong operational mindset, familiar with MSHA safety guidelines, industry knowledge, and the ability to analyze complex data into actionable recommendations. With a focus on continuous improvement, efficiency, and project execution, the Project Engineer is integral to enhancing both operational performance and efficiency at Turner Mining Group.<\/p>\n<p><strong><u>Position Responsibilities:<\/u><\/strong><\/p>\n<p><strong>Operational &amp; Technical Analysis<\/strong><\/p>\n<ul><li>Review operational reports (cost, safety, production) and analyze data for key trends.<\/li><li>Develop and implement continuous improvement initiatives to enhance efficiency and reduce costs.<\/li><li>Conduct risk assessments for operational, technical, and financial aspects of mining projects.<\/li><li>Collaborate with engineering and operations teams to optimize mine planning, design, and extraction techniques.<\/li><li>Develop and track key performance indicators (KPIs) to monitor operational performance and drive improvements.<\/li><\/ul>\n<p><strong>Mine Engineering &amp; Survey Duties<\/strong><\/p>\n<ul><li>Manage fleet management and high precision GPS systems.<\/li><li>Develop Drill &amp; Blast pattern, profile, and timing designs and short-range plans.<\/li><li>Produce road designs, stockpile and waste storage designs, and others in Hexagon MineSight.<\/li><li>Operate survey drones and reconcile results.<\/li><li>Analyze FMS and other data for risks and opportunities.<\/li><li>Audit and advise client on short range mine plans.<\/li><\/ul>\n<p><strong>Client &amp; Cross-Functional Collaboration<\/strong><\/p>\n<ul><li>Work closely with Turner Mining departments and external stakeholders to define project scopes and execution strategies.<\/li><li>Act as a technical link between client technical services and project management to ensure alignment on operational objectives.<\/li><li>Participate in knowledge-sharing initiatives, such as internal workshops and training, to support operational and analytical capabilities across teams.<\/li><li>Engage with suppliers and service providers to optimize procurement strategies for project operations.<\/li><\/ul>\n<p><strong>Compliance and Safety Integration<\/strong><\/p>\n<ul><li>Ensure that all engineering recommendations align with MSHA safety regulations and industry best practices.<\/li><li>Develop and maintain standard operating procedures (SOPs) for operational and safety processes.<\/li><li>Provide technical guidance to ensure site compliance with environmental and regulatory requirements.<\/li><\/ul>\n<ul><li>Other duties as required.<\/li><\/ul>\n<p><strong>The Ideal Candidate:<\/strong><\/p>\n<p><strong>Education and Experience<\/strong><\/p>\n<ul><li>Mining or Civil Engineering Degree or related.<\/li><li>3 years of mine site engineering or operational experience.<\/li><li>Hands-on experience with mining engineering software (Hexagon MineSight preferred or similar).<\/li><li>Strong proficiency in MS Office (Word, Excel, PowerPoint, Outlook).<\/li><li>Part 107 drone license preferred<\/li><li>Procurement and mine accounting experience preferred<\/li><\/ul>\n<p><strong>Technical and Analytical Skills<\/strong><\/p>\n<ul><li>Strong problem-solving and data analysis capabilities.<\/li><li>Ability to translate complex engineering data into actionable recommendations.<\/li><li>Knowledge of drill &amp; blast design, mine haulage analysis, and GPS fleet management.<\/li><li>Familiarity with mine accounting and procurement processes (preferred but not required).<\/li><\/ul>\n<p><strong>Key Competencies \/ Skills<\/strong><\/p>\n<ul><li>Results-oriented with a proactive, problem-solving mindset.<\/li><li>Effective communicator, capable of working with cross-functional teams and clients.<\/li><li>Ability to work independently and manage multiple priorities in a dynamic environment.<\/li><li>Detail-oriented with strong documentation and technical writing skills.<\/li><\/ul>\n<p><strong><u>Benefits<\/u><\/strong><\/p>\n<p>Turner Mining Group offers a competitive salary, an excellent work culture, and career advancement opportunities. Our team provides a benefits program which includes Medical, Dental, Vision, Life, and a 401k with company match. We believe in a work-life balance and have established paid time off for major holidays.<\/p>\n<p>At Turner Mining Group, we encourage and celebrate an inclusive environment for all employees and are proud to be an equal opportunity workplace and affirmative action employer.<\/p>","post_title":"Project Engineer &#8211; Mining","post_link":"https:\/\/turnerstaffing.com\/position\/project-engineer-mining-3\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Mid Level","%location_country%":"United States","%location_city%":"Ely","%location_state_id%":"NV","%location_state_name%":"Nevada","%location_city_state%":"Ely, NV","%education%":"Bachelor's Degree","%department%":"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<ul><li>Review operational reports (cost, safety, production) and analyze data for key trends.<\/li><li>Develop and implement continuous improvement initiatives to enhance efficiency and reduce costs.<\/li><li>Conduct risk assessments for operational, technical, and financial aspects of mining projects.<\/li><li>Collaborate with engineering and operations teams to optimize mine planning, design, and extraction techniques.<\/li><li>Develop and track key performance indicators (KPIs) to monitor operational performance and drive improvements.<\/li><\/ul>\n<p><strong>Mine Engineering &amp; Survey Duties<\/strong><\/p>\n<ul><li>Manage fleet management and high precision GPS systems.<\/li><li>Develop Drill &amp; Blast pattern, profile, and timing designs and short-range plans.<\/li><li>Produce road designs, stockpile and waste storage designs, and others in Hexagon MineSight.<\/li><li>Operate survey drones and reconcile results.<\/li><li>Analyze FMS and other data for risks and opportunities.<\/li><li>Audit and advise client on short range mine plans.<\/li><\/ul>\n<p><strong>Client &amp; Cross-Functional Collaboration<\/strong><\/p>\n<ul><li>Work closely with Turner Mining departments and external stakeholders to define project scopes and execution strategies.<\/li><li>Act as a technical link between client technical services and project management to ensure alignment on operational objectives.<\/li><li>Participate in knowledge-sharing initiatives, such as internal workshops and training, to support operational and analytical capabilities across teams.<\/li><li>Engage with suppliers and service providers to optimize procurement strategies for project operations.<\/li><\/ul>\n<p><strong>Compliance and Safety Integration<\/strong><\/p>\n<ul><li>Ensure that all engineering recommendations align with MSHA safety regulations and industry best practices.<\/li><li>Develop and maintain standard operating procedures (SOPs) for operational and safety processes.<\/li><li>Provide technical guidance to ensure site compliance with environmental and regulatory requirements.<\/li><\/ul>\n<ul><li>Other duties as required.<\/li><\/ul>\n<p><strong>The Ideal Candidate:<\/strong><\/p>\n<p><strong>Education and Experience<\/strong><\/p>\n<ul><li>Mining or Civil Engineering Degree or related.<\/li><li>3 years of mine site engineering or operational experience.<\/li><li>Hands-on experience with mining engineering software (Hexagon MineSight preferred or similar).<\/li><li>Strong proficiency in MS Office (Word, Excel, PowerPoint, Outlook).<\/li><li>Part 107 drone license preferred<\/li><li>Procurement and mine accounting experience preferred<\/li><\/ul>\n<p><strong>Technical and Analytical Skills<\/strong><\/p>\n<ul><li>Strong problem-solving and data analysis capabilities.<\/li><li>Ability to translate complex engineering data into actionable recommendations.<\/li><li>Knowledge of drill &amp; blast design, mine haulage analysis, and GPS fleet management.<\/li><li>Familiarity with mine accounting and procurement processes (preferred but not required).<\/li><\/ul>\n<p><strong>Key Competencies \/ Skills<\/strong><\/p>\n<ul><li>Results-oriented with a proactive, problem-solving mindset.<\/li><li>Effective communicator, capable of working with cross-functional teams and clients.<\/li><li>Ability to work independently and manage multiple priorities in a dynamic environment.<\/li><li>Detail-oriented with strong documentation and technical writing skills.<\/li><\/ul>\n<p><strong><u>Benefits<\/u><\/strong><\/p>\n<p>Turner Mining Group offers a competitive salary, an excellent work culture, and career advancement opportunities. Our team provides a benefits program which includes Medical, Dental, Vision, Life, and a 401k with company match. We believe in a work-life balance and have established paid time off for major holidays.<\/p>\n<p>At Turner Mining Group, we encourage and celebrate an inclusive environment for all employees and are proud to be an equal opportunity workplace and affirmative action employer.<\/p>","%category%":"Other","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/54f229b92403-project-engineer-mining","%breezy_id%":"54f229b92403","%breezy_friendly_id%":"54f229b92403-project-engineer-mining","%breezy_created_date%":"2025-10-13T17:52:34.748Z","%breezy_updated_date%":"2025-10-13T17:53:36.260Z","%_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":2825,"infowindow_disable":false},{"source":"post","title":"Maintenance Planner","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Maintenance Planner\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Key Responsibilities: Maintenance Planning &amp; Scheduling: \uf0a7 Oversee tracking of all equipment. \uf0a7 Schedule, and coordinate planned maintenance (PM) and&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/maintenance-planner\/\" name=\"Maintenance Planner\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Key Responsibilities: Maintenance Planning &amp; Scheduling: \uf0a7 Oversee tracking of all equipment. \uf0a7 Schedule, and coordinate planned maintenance (PM) and&hellip;","address":"Elko, NV, USA","location":{"lat":"40.8436459","city":"Elko","state":"NV","country":"United States","lng":"-115.7526187","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/maintenance-planner\/","zoom":19,"extra_fields":{"post_excerpt":"Key Responsibilities: Maintenance Planning &amp; Scheduling: \uf0a7 Oversee tracking of all equipment. \uf0a7 Schedule, and coordinate planned maintenance (PM) and&hellip;","post_content":"<p>Key Responsibilities:<\/p>\n<p>Maintenance Planning &amp; Scheduling:<\/p>\n<p>\uf0a7 Oversee tracking of all equipment.<\/p>\n<p>\uf0a7 Schedule, and coordinate planned maintenance (PM) and corrective maintenance (CM) activities.<\/p>\n<p>\uf0a7 Manage and prioritize work orders, ensuring accurate documentation and execution of maintenance and inspection tasks.<\/p>\n<p>\uf0a7 Utilize Equipment Service Requests (ESRs) to plan, track, and close maintenance and service tasks.<\/p>\n<p>\uf0a7 Plan equipment shutdowns and service intervals in collaboration with field operations and drilling schedules.<\/p>\n<p>Service, Work Orders &amp; Inspections<\/p>\n<p>\uf0a7 Schedule and coordinate routine inspections and service intervals, and ensure their completion (e.g., work orders, crane inspections, pressure vessels, fire inspections, DOT and safety compliance).<\/p>\n<p>\uf0a7 Maintain accurate records of all maintenance work performed, including documentation of corrective actions.<\/p>\n<p>\uf0a7 Interface with field personnel and supervisors to gather feedback and adjust schedules as needed.<\/p>\n<p>Inventory &amp; Parts:<\/p>\n<p>\uf0a7 Ensure critical spares and parts are available to support scheduled and unscheduled maintenance.<\/p>\n<p>\uf0a7 Collaborate with supply chain and warehouse teams to maintain accurate inventory levels and forecast usage.<\/p>\n<p>\uf0a7 Provide input on inventory planning, parts kitting, and reorder thresholds based on usage data and failure trends.<\/p>\n<p>Warranty &amp; Component Failure Management<\/p>\n<p>\uf0a7 Track and manage warranty claims for parts and equipment to ensure cost recovery.<\/p>\n<p>\uf0a7 Log and analyze component failures to identify trends, or recurring issues.<\/p>\n<p>Trend Analysis &amp; Reporting<\/p>\n<p>\uf0a7 Monitor and report on premature failure trends.<\/p>\n<p>Equipment Damage Reporting<\/p>\n<p>\uf0a7 Create and distribute Equipment Damage Reports.<\/p>\n<p>\uf0a7 Use damage data to develop prevention strategies and reduce repeat incidents.<\/p>\n<p>Qualifications &amp; Experience:<\/p>\n<p>\uf0a7 Minimum 3-5 years\u2019 experience in maintenance planning, preferably in drilling, oil &amp; gas, or heavy equipment industries.<\/p>\n<p>\uf0a7 Strong knowledge of drilling equipment, hydraulic systems, diesel engines, and rotating equipment.<\/p>\n<p>\uf0a7 Proficient in MS Office Suite. Preferred ERP systems experience.<\/p>\n<p>\uf0a7 Familiarity with warranty management, component lifecycle tracking, and reliability principles.<\/p>\n<p>Skills &amp; Competencies:<\/p>\n<p>\uf0a7 High attention to detail with strong organizational and time management skills.<\/p>\n<p>\uf0a7 Analytical mindset with the ability to identify trends and propose actionable solutions.<\/p>\n<p>\uf0a7 Excellent communication and interpersonal skills for coordination across departments and with external vendors.<\/p>\n<p>\uf0a7 Proactive approach to problem-solving and continuous improvement.<\/p>","post_title":"Maintenance Planner","post_link":"https:\/\/turnerstaffing.com\/position\/maintenance-planner\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Mid Level","%location_country%":"United States","%location_city%":"Elko","%location_state_id%":"NV","%location_state_name%":"Nevada","%location_city_state%":"Elko, NV","%education%":"Unspecified","%department%":"","%description%":"<p>Key Responsibilities:<\/p>\n<p>Maintenance Planning &amp; Scheduling:<\/p>\n<p>\uf0a7 Oversee tracking of all equipment.<\/p>\n<p>\uf0a7 Schedule, and coordinate planned maintenance (PM) and corrective maintenance (CM) activities.<\/p>\n<p>\uf0a7 Manage and prioritize work orders, ensuring accurate documentation and execution of maintenance and inspection tasks.<\/p>\n<p>\uf0a7 Utilize Equipment Service Requests (ESRs) to plan, track, and close maintenance and service tasks.<\/p>\n<p>\uf0a7 Plan equipment shutdowns and service intervals in collaboration with field operations and drilling schedules.<\/p>\n<p>Service, Work Orders &amp; Inspections<\/p>\n<p>\uf0a7 Schedule and coordinate routine inspections and service intervals, and ensure their completion (e.g., work orders, crane inspections, pressure vessels, fire inspections, DOT and safety compliance).<\/p>\n<p>\uf0a7 Maintain accurate records of all maintenance work performed, including documentation of corrective actions.<\/p>\n<p>\uf0a7 Interface with field personnel and supervisors to gather feedback and adjust schedules as needed.<\/p>\n<p>Inventory &amp; Parts:<\/p>\n<p>\uf0a7 Ensure critical spares and parts are available to support scheduled and unscheduled maintenance.<\/p>\n<p>\uf0a7 Collaborate with supply chain and warehouse teams to maintain accurate inventory levels and forecast usage.<\/p>\n<p>\uf0a7 Provide input on inventory planning, parts kitting, and reorder thresholds based on usage data and failure trends.<\/p>\n<p>Warranty &amp; Component Failure Management<\/p>\n<p>\uf0a7 Track and manage warranty claims for parts and equipment to ensure cost recovery.<\/p>\n<p>\uf0a7 Log and analyze component failures to identify trends, or recurring issues.<\/p>\n<p>Trend Analysis &amp; Reporting<\/p>\n<p>\uf0a7 Monitor and report on premature failure trends.<\/p>\n<p>Equipment Damage Reporting<\/p>\n<p>\uf0a7 Create and distribute Equipment Damage Reports.<\/p>\n<p>\uf0a7 Use damage data to develop prevention strategies and reduce repeat incidents.<\/p>\n<p>Qualifications &amp; Experience:<\/p>\n<p>\uf0a7 Minimum 3-5 years\u2019 experience in maintenance planning, preferably in drilling, oil &amp; gas, or heavy equipment industries.<\/p>\n<p>\uf0a7 Strong knowledge of drilling equipment, hydraulic systems, diesel engines, and rotating equipment.<\/p>\n<p>\uf0a7 Proficient in MS Office Suite. Preferred ERP systems experience.<\/p>\n<p>\uf0a7 Familiarity with warranty management, component lifecycle tracking, and reliability principles.<\/p>\n<p>Skills &amp; Competencies:<\/p>\n<p>\uf0a7 High attention to detail with strong organizational and time management skills.<\/p>\n<p>\uf0a7 Analytical mindset with the ability to identify trends and propose actionable solutions.<\/p>\n<p>\uf0a7 Excellent communication and interpersonal skills for coordination across departments and with external vendors.<\/p>\n<p>\uf0a7 Proactive approach to problem-solving and continuous improvement.<\/p>","%category%":"Operations","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/92029d768468-maintenance-planner","%breezy_id%":"92029d768468","%breezy_friendly_id%":"92029d768468-maintenance-planner","%breezy_created_date%":"2025-10-13T18:20:07.500Z","%breezy_updated_date%":"2025-10-13T18:20:39.274Z","%_wpgmp_location_city%":"Elko","%_wpgmp_location_state%":"NV","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Elko, NV, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"40.8436459","%_wpgmp_metabox_longitude%":"-115.7526187","%rank_math_internal_links_processed%":"1"}},"id":2826,"infowindow_disable":false},{"source":"post","title":"Equipment Superintendent &#8211; Mining","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Equipment Superintendent &#8211; Mining\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Equipment Superintendent Job Description Manage Project maintenance and Equipment Vendor personnel Reports to Project Manager Safety Leadership Invest, teach, and&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/equipment-superintendent-mining-2\/\" name=\"Equipment Superintendent &#8211; Mining\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Equipment Superintendent Job Description Manage Project maintenance and Equipment Vendor personnel Reports to Project Manager Safety Leadership Invest, teach, and&hellip;","address":"Ely, NV, USA","location":{"lat":"39.2533328","city":"Ely","state":"NV","country":"United States","lng":"-114.874248","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/equipment-superintendent-mining-2\/","zoom":19,"extra_fields":{"post_excerpt":"Equipment Superintendent Job Description Manage Project maintenance and Equipment Vendor personnel Reports to Project Manager Safety Leadership Invest, teach, and&hellip;","post_content":"<p><strong><u>Equipment Superintendent Job Description<\/u><\/strong><\/p>\n<p><strong>Manage Project maintenance and Equipment Vendor personnel Reports to Project Manager<\/strong><\/p>\n<p><strong><u>Safety Leadership<\/u><\/strong><\/p>\n<ul><li>Invest, teach, and mentor project maintenance personnel to foster \"An Eye For Safety\u201d environment at the site<\/li><li>Mitigate onsite safety risks<\/li><li>Ensure all MSHA regulations are followed and maintain site safety standards<\/li><li>Conduct and participate in monthly site safety meetings to discuss incidents, safety trends, behavior goals, etc.<\/li><li>Ensure all workplace exams are complete and accurate<\/li><li>Task training is completed correctly and stored<\/li><li>Pre-operational inspection issues are corrected, and forms are filed according to the TMG process<\/li><li>All safety documents are filed and stored on-site<\/li><li>Follow the TMG process for incident investigation and response<\/li><li>Complete incident report in HCSS Safety<\/li><li>Provide employees with a safe and healthy work environment by providing safe systems of work, safe work procedures, adequate training and instruction, and competent supervision<\/li><li>Review hazard identification, near miss, and incident reports and provide follow-up as appropriate<\/li><li>Ensure maintenance employees and contractors working within the Site Project personnel are prequalified and have the necessary commencement paperwork, competencies, and qualifications to work safely and deliver quality maintenance services (has Stop Work Authority if standards are not met)<\/li><\/ul>\n<p><strong><u>Major Responsibilities<\/u><\/strong><\/p>\n<ul><li>Spend considerable time in the field interacting with the workforce \u2013 Creating \u201c<strong>visible felt<\/strong>&nbsp;<strong>leadership<\/strong>\u201d ~25 to 40% of working time<\/li><li>TMG fuel and lube technicians will report to the role<\/li><li>Manager equipment vendor maintenance personnel and coordinate their site activities<\/li><li>Develop systems and foster the required collaboration to ensure the department meets monthly targets<\/li><li>Review competencies, Scopes of Work, and Schedules of Rates for all Contractors, ensuring costs are managed and controlled while complying with Contractor Controls Policies and Procedures<\/li><li>Help develop maintenance strategy objectives and ensure they are met<\/li><li>Improve Equipment\/Operations Performance by Optimize Equipment &amp; Fleet Asset Reliability<\/li><li>Ensure the effective and efficient application of maintenance resources, as measured by schedule compliance, PM compliance, the level of planned vs. unplanned work, and the ongoing management of backlog<\/li><li>Create service requests, work orders, and purchase orders for repairs\/purchases in the TMG accounting systems and communicating with vendors during the purchase process<\/li><li>Assist Project Manager as needed with tracking maintenance costs and accounting<\/li><li>Participate in incident investigations (injury, high-potential, and equipment damage) to ensure that corrective actions are effectively implemented and tracked<\/li><li>Support the development and ongoing optimization of maintenance strategies for critical assets.<\/li><li>Complete performance evaluation reviews for direct reports and manage their career development.<\/li><li>Recruit for Maintenance positions. Ensure that succession planning for critical roles is in place<\/li><li>Ensure applicable maintenance training is provided as required<\/li><li>Communicate daily needs with Project team<\/li><li>Develop an equipment coordinator position if the need arises in the future<\/li><li>Manage equipment costs, repairs, rebuilds, warrantee items, and equipment replacements<\/li><li>Manage field services for operations: service and mechanics trucks, tools, etc.<\/li><li>These responsibilities are required but not limited to and others may be assigned by the Project Manager as needed<\/li><\/ul>\n<p><strong><u>Preferred Candidate Requirements:<\/u><\/strong><\/p>\n<ul><li>Minimum 5-7 years Maintenance General Foreman level or higher experience in heavy industry<\/li><li>Minimum of 4 years of management of the maintenance scheduling and workflow function<\/li><\/ul>\n<p><strong><u>Personnel Management<\/u><\/strong><\/p>\n<ul><li>Submit hiring requests\/termination requisitions to HR following the TMG process<\/li><li>Conduct interviews for maintenance employees<\/li><li>Complete employee reviews using the TMG form and submit them for approval<\/li><li>Evaluate maintenance personnel performance<\/li><li>Document employee issues\/ disciplinary action, send to Project Manager and HR<\/li><li>Maintain complete knowledge of the employee handbook<\/li><\/ul>\n<p><strong><u>Benefits<\/u><\/strong><\/p>\n<p>Turner Mining Group offers a competitive salary, an excellent work culture, and career advancement opportunities. Our team provides a benefits program which includes Medical, Dental, Vision, Life, and a 401k with company match. We believe in a work-life balance and have established paid time off for major holidays.<\/p>\n<p>At Turner Mining Group, we encourage and celebrate an inclusive environment for all employees and are proud to be an equal opportunity workplace and affirmative action employer.<\/p>","post_title":"Equipment Superintendent &#8211; Mining","post_link":"https:\/\/turnerstaffing.com\/position\/equipment-superintendent-mining-2\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Senior","%location_country%":"United States","%location_city%":"Ely","%location_state_id%":"NV","%location_state_name%":"Nevada","%location_city_state%":"Ely, NV","%education%":"Unspecified","%department%":"Equipment","%description%":"<p><strong><u>Equipment Superintendent Job Description<\/u><\/strong><\/p>\n<p><strong>Manage Project maintenance and Equipment Vendor personnel Reports to Project Manager<\/strong><\/p>\n<p><strong><u>Safety Leadership<\/u><\/strong><\/p>\n<ul><li>Invest, teach, and mentor project maintenance personnel to foster \"An Eye For Safety\u201d environment at the site<\/li><li>Mitigate onsite safety risks<\/li><li>Ensure all MSHA regulations are followed and maintain site safety standards<\/li><li>Conduct and participate in monthly site safety meetings to discuss incidents, safety trends, behavior goals, etc.<\/li><li>Ensure all workplace exams are complete and accurate<\/li><li>Task training is completed correctly and stored<\/li><li>Pre-operational inspection issues are corrected, and forms are filed according to the TMG process<\/li><li>All safety documents are filed and stored on-site<\/li><li>Follow the TMG process for incident investigation and response<\/li><li>Complete incident report in HCSS Safety<\/li><li>Provide employees with a safe and healthy work environment by providing safe systems of work, safe work procedures, adequate training and instruction, and competent supervision<\/li><li>Review hazard identification, near miss, and incident reports and provide follow-up as appropriate<\/li><li>Ensure maintenance employees and contractors working within the Site Project personnel are prequalified and have the necessary commencement paperwork, competencies, and qualifications to work safely and deliver quality maintenance services (has Stop Work Authority if standards are not met)<\/li><\/ul>\n<p><strong><u>Major Responsibilities<\/u><\/strong><\/p>\n<ul><li>Spend considerable time in the field interacting with the workforce \u2013 Creating \u201c<strong>visible felt<\/strong>&nbsp;<strong>leadership<\/strong>\u201d ~25 to 40% of working time<\/li><li>TMG fuel and lube technicians will report to the role<\/li><li>Manager equipment vendor maintenance personnel and coordinate their site activities<\/li><li>Develop systems and foster the required collaboration to ensure the department meets monthly targets<\/li><li>Review competencies, Scopes of Work, and Schedules of Rates for all Contractors, ensuring costs are managed and controlled while complying with Contractor Controls Policies and Procedures<\/li><li>Help develop maintenance strategy objectives and ensure they are met<\/li><li>Improve Equipment\/Operations Performance by Optimize Equipment &amp; Fleet Asset Reliability<\/li><li>Ensure the effective and efficient application of maintenance resources, as measured by schedule compliance, PM compliance, the level of planned vs. unplanned work, and the ongoing management of backlog<\/li><li>Create service requests, work orders, and purchase orders for repairs\/purchases in the TMG accounting systems and communicating with vendors during the purchase process<\/li><li>Assist Project Manager as needed with tracking maintenance costs and accounting<\/li><li>Participate in incident investigations (injury, high-potential, and equipment damage) to ensure that corrective actions are effectively implemented and tracked<\/li><li>Support the development and ongoing optimization of maintenance strategies for critical assets.<\/li><li>Complete performance evaluation reviews for direct reports and manage their career development.<\/li><li>Recruit for Maintenance positions. Ensure that succession planning for critical roles is in place<\/li><li>Ensure applicable maintenance training is provided as required<\/li><li>Communicate daily needs with Project team<\/li><li>Develop an equipment coordinator position if the need arises in the future<\/li><li>Manage equipment costs, repairs, rebuilds, warrantee items, and equipment replacements<\/li><li>Manage field services for operations: service and mechanics trucks, tools, etc.<\/li><li>These responsibilities are required but not limited to and others may be assigned by the Project Manager as needed<\/li><\/ul>\n<p><strong><u>Preferred Candidate Requirements:<\/u><\/strong><\/p>\n<ul><li>Minimum 5-7 years Maintenance General Foreman level or higher experience in heavy industry<\/li><li>Minimum of 4 years of management of the maintenance scheduling and workflow function<\/li><\/ul>\n<p><strong><u>Personnel Management<\/u><\/strong><\/p>\n<ul><li>Submit hiring requests\/termination requisitions to HR following the TMG process<\/li><li>Conduct interviews for maintenance employees<\/li><li>Complete employee reviews using the TMG form and submit them for approval<\/li><li>Evaluate maintenance personnel performance<\/li><li>Document employee issues\/ disciplinary action, send to Project Manager and HR<\/li><li>Maintain complete knowledge of the employee handbook<\/li><\/ul>\n<p><strong><u>Benefits<\/u><\/strong><\/p>\n<p>Turner Mining Group offers a competitive salary, an excellent work culture, and career advancement opportunities. Our team provides a benefits program which includes Medical, Dental, Vision, Life, and a 401k with company match. We believe in a work-life balance and have established paid time off for major holidays.<\/p>\n<p>At Turner Mining Group, we encourage and celebrate an inclusive environment for all employees and are proud to be an equal opportunity workplace and affirmative action employer.<\/p>","%category%":"Management","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/9c07b0f7300d-equipment-superintendent-mining","%breezy_id%":"9c07b0f7300d","%breezy_friendly_id%":"9c07b0f7300d-equipment-superintendent-mining","%breezy_created_date%":"2025-10-13T16:42:16.862Z","%breezy_updated_date%":"2025-10-13T16:43:01.350Z","%_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":2823,"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-3\/\" name=\"Operations Superintendent &#8211; Mining\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Turner Mining Group &#8211; Project Superintendent We are looking for a dynamic and talented mining industry leader to fill a&hellip;","address":"Ely, NV, USA","location":{"lat":"39.2533328","city":"Ely","state":"NV","country":"United States","lng":"-114.874248","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/operations-superintendent-mining-3\/","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-3\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Mid Level","%location_country%":"United States","%location_city%":"Ely","%location_state_id%":"NV","%location_state_name%":"Nevada","%location_city_state%":"Ely, NV","%education%":"Unspecified","%department%":"Operations","%description%":"<p><strong><u>Turner Mining Group - Project Superintendent<\/u><\/strong><br><\/p>\n<p>We are looking for a dynamic and talented mining industry leader to fill a Project Superintendent role at our fast-growing, forward thinking mining services company.<\/p>\n<p>Turner Mining Group is seeking an energetic mining professional who can leverage their mining industry experience to expand upon our fast-growing business, creating best practices for operations management and scalable business processes to ensure profitable projects.<\/p>\n<p>This person will function as a Project Superintendent, overseeing mining operations, work directly with the Senior Vice President of Mining, develop and mentor on-site management, and coordinating with home-office team. Leadership and an ability to problem solve while ensuring mining operations remain on budget and ahead of schedule. This is an opportunity to work as part of the executive leadership team in a fast-paced and flexible environment.<\/p>\n<p><strong>You<\/strong><\/p>\n<p>You want to work for a services company that is rapidly changing the way the largest mining producers do business. You are motivated by solving problems and partnering with our clients and suppliers. You want to work with great people and enjoy being a part of a strong team. You are a seasoned mining leader who is not afraid to jump into every detail. You want to be in a place where continuous learning and growth is the norm. You are adaptable and able to juggle multiple initiatives concurrently.<\/p>\n<p><strong>Position Overview<\/strong><\/p>\n<p>The Project Superintendent primary responsibility is to oversee mining operations within Turner Mining Group. This will include managing the operational and financial performance of projects, implementing processes to ensure effective personnel growth, equipment readiness, client interactions and problem solving and implementing systems and tools to increase efficiency and ensure profitability. Position reports directly to the Director of Operations.<\/p>\n<p><strong>Key Responsibilities<\/strong><\/p>\n<ul><li>Conduct field personnel development by training and monitoring: Equipment operators, maintenance technicians, grade staking, GPS utilization, foremen\u2019s, etc.<\/li><li>Ownership for project budget, profitability, and cost control<\/li><li>Identify, assist with develop, and understand the key financial and operational metrics for success<\/li><li>Oversee operations for safety and compliance<\/li><li>Developing and leading fields teams to increase performance<\/li><li>Implement business division reporting and metrics reviews<\/li><li>Coordinate site needs, crews for scheduling, planning, and resources<\/li><li>Monitor forward-looking personnel requirements and vendor developments<\/li><li>Negotiate and manage client and vendor relationships<\/li><li>Approve appropriate invoices and proposal submissions<\/li><li>Assist Biz Dev &amp; Estimation Team with Pre-Bid site visits, analysis, and work plans for project proposals<\/li><\/ul>\n<p><strong>Essential Skills &amp; Knowledge<\/strong><\/p>\n<ul><li>Detailed understanding of civil and mining operations<\/li><li>General understanding of business leadership<\/li><li>Ability to oversee operational and organizational performance for mining projects<\/li><li>Solid understanding of financial and operational reporting<\/li><li>Ability to quantify and explain variances to owners and executives succinctly and clearly<\/li><li>Proficiency in civil and mining best practices to perform project management<\/li><li>Intelligent with demonstrated results from creativity<\/li><li>Willingness to learn what is takes to run growing and successful teams<\/li><li>Strong organizational, interpersonal, and written communication skill<\/li><li>Gifted person who can prioritize and balance competing initiatives and activities<\/li><li>Knack for continuous improvement of processes, solution-based issue resolution and outcomes<\/li><li>Organized, problem solver and solution developer, who can work with workers, engineers and owner teams<\/li><li>Believe in the power of culture with strong leadership qualities<\/li><\/ul>\n<p><strong>Benefits<\/strong><\/p>\n<p>Turner Mining Group offers a competitive salary, an excellent work culture, career advancement opportunities. Our team offers a benefits program which includes Medical, Dental, Vision, Life, and a 401k with company match. We believe in a work life balance and established a Paid Time Off policy as well as paid time off for major holidays.<\/p>\n<p>At Turner Mining Group, we encourage and celebrate an inclusive environment for all employees and are proud to be an equal opportunity workplace and affirmative action employer.<\/p>","%category%":"Operations","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/0baa9194179e-operations-superintendent-mining","%breezy_id%":"0baa9194179e","%breezy_friendly_id%":"0baa9194179e-operations-superintendent-mining","%breezy_created_date%":"2025-10-13T16:46:50.435Z","%breezy_updated_date%":"2025-10-13T16:47:45.648Z","%_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":2824,"infowindow_disable":false},{"source":"post","title":"Operations Superintendent","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Operations Superintendent\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Turner Mining Group &#8211; Project Superintendent We are looking for a dynamic and talented mining industry leader to fill a&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/operations-superintendent-2\/\" name=\"Operations Superintendent\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Turner Mining Group &#8211; Project Superintendent We are looking for a dynamic and talented mining industry leader to fill a&hellip;","address":"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\/operations-superintendent-2\/","zoom":19,"extra_fields":{"post_excerpt":"Turner Mining Group &#8211; Project Superintendent We are looking for a dynamic and talented mining industry leader to fill a&hellip;","post_content":"<p><strong><u>Turner Mining Group - Project Superintendent <\/u><\/strong><br><\/p>\n<p>We are looking for a dynamic and talented mining industry leader to fill a Project Superintendent role at our fast-growing, forward thinking mining services company.<\/p>\n<p>Turner Mining Group is seeking an energetic mining professional who can leverage their mining industry experience to expand upon our fast-growing business, creating best practices for operations management and scalable business processes to ensure profitable projects. <\/p>\n<p>This person will function as a Project Superintendent, overseeing mining operations, work directly with the Senior Vice President of Mining, develop and mentor on-site management, and coordinating with home-office team. Leadership and an ability to problem solve while ensuring mining operations remain on budget and ahead of schedule. This is an opportunity to work as part of the executive leadership team in a fast-paced and flexible environment.<\/p>\n<p><strong>You<\/strong><\/p>\n<p>You want to work for a services company that is rapidly changing the way the largest mining producers do business. You are motivated by solving problems and partnering with our clients and suppliers. You want to work with great people and enjoy being a part of a strong team. You are a seasoned mining leader who is not afraid to jump into every detail. You want to be in a place where continuous learning and growth is the norm. You are adaptable and able to juggle multiple initiatives concurrently.<\/p>\n<p><strong>Position Overview<\/strong><\/p>\n<p>The Project Superintendent primary responsibility is to oversee mining operations within Turner Mining Group. This will include managing the operational and financial performance of projects, implementing processes to ensure effective personnel growth, equipment readiness, client interactions and problem solving and implementing systems and tools to increase efficiency and ensure profitability. Position reports directly to the Director of Operations.<\/p>\n<p><strong>Key Responsibilities<\/strong><\/p>\n<ul><li>Conduct field personnel development by training and monitoring: Equipment operators, maintenance technicians, grade staking, GPS utilization, foremen\u2019s, etc.<\/li><li>Ownership for project budget, profitability, and cost control<\/li><li>Identify, assist with develop, and understand the key financial and operational metrics for success<\/li><li>Oversee operations for safety and compliance<\/li><li>Developing and leading fields teams to increase performance<\/li><li>Implement business division reporting and metrics reviews<\/li><li>Coordinate site needs, crews for scheduling, planning, and resources<\/li><li>Monitor forward-looking personnel requirements and vendor developments<\/li><li>Negotiate and manage client and vendor relationships<\/li><li>Approve appropriate invoices and proposal submissions<\/li><li>Assist Biz Dev &amp; Estimation Team with Pre-Bid site visits, analysis, and work plans for project proposals<\/li><\/ul>\n<p><strong>Essential Skills &amp; Knowledge<\/strong><\/p>\n<ul><li>Detailed understanding of civil and mining operations<\/li><li>General understanding of business leadership<\/li><li>Ability to oversee operational and organizational performance for mining projects<\/li><li>Solid understanding of financial and operational reporting<\/li><li>Ability to quantify and explain variances to owners and executives succinctly and clearly<\/li><li>Proficiency in civil and mining best practices to perform project management<\/li><li>Intelligent with demonstrated results from creativity<\/li><li>Willingness to learn what is takes to run growing and successful teams<\/li><li>Strong organizational, interpersonal, and written communication skill<\/li><li>Gifted person who can prioritize and balance competing initiatives and activities<\/li><li>Knack for continuous improvement of processes, solution-based issue resolution and outcomes<\/li><li>Organized, problem solver and solution developer, who can work with workers, engineers and owner teams<\/li><li>Believe in the power of culture with strong leadership qualities<\/li><\/ul>\n<p><strong>Benefits<\/strong><\/p>\n<p>Turner Mining Group offers a competitive salary, an excellent work culture, career advancement opportunities. Our team offers a benefits program which includes Medical, Dental, Vision, Life, and a 401k with company match. We believe in a work life balance and established a Paid Time Off policy as well as paid time off for major holidays.<\/p>\n<p>At Turner Mining Group, we encourage and celebrate an inclusive environment for all employees and are proud to be an equal opportunity workplace and affirmative action employer.<\/p>","post_title":"Operations Superintendent","post_link":"https:\/\/turnerstaffing.com\/position\/operations-superintendent-2\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Mid Level","%location_country%":"United States","%location_city%":"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<p>We are looking for a dynamic and talented mining industry leader to fill a Project Superintendent role at our fast-growing, forward thinking mining services company.<\/p>\n<p>Turner Mining Group is seeking an energetic mining professional who can leverage their mining industry experience to expand upon our fast-growing business, creating best practices for operations management and scalable business processes to ensure profitable projects. <\/p>\n<p>This person will function as a Project Superintendent, overseeing mining operations, work directly with the Senior Vice President of Mining, develop and mentor on-site management, and coordinating with home-office team. Leadership and an ability to problem solve while ensuring mining operations remain on budget and ahead of schedule. This is an opportunity to work as part of the executive leadership team in a fast-paced and flexible environment.<\/p>\n<p><strong>You<\/strong><\/p>\n<p>You want to work for a services company that is rapidly changing the way the largest mining producers do business. You are motivated by solving problems and partnering with our clients and suppliers. You want to work with great people and enjoy being a part of a strong team. You are a seasoned mining leader who is not afraid to jump into every detail. You want to be in a place where continuous learning and growth is the norm. You are adaptable and able to juggle multiple initiatives concurrently.<\/p>\n<p><strong>Position Overview<\/strong><\/p>\n<p>The Project Superintendent primary responsibility is to oversee mining operations within Turner Mining Group. This will include managing the operational and financial performance of projects, implementing processes to ensure effective personnel growth, equipment readiness, client interactions and problem solving and implementing systems and tools to increase efficiency and ensure profitability. Position reports directly to the Director of Operations.<\/p>\n<p><strong>Key Responsibilities<\/strong><\/p>\n<ul><li>Conduct field personnel development by training and monitoring: Equipment operators, maintenance technicians, grade staking, GPS utilization, foremen\u2019s, etc.<\/li><li>Ownership for project budget, profitability, and cost control<\/li><li>Identify, assist with develop, and understand the key financial and operational metrics for success<\/li><li>Oversee operations for safety and compliance<\/li><li>Developing and leading fields teams to increase performance<\/li><li>Implement business division reporting and metrics reviews<\/li><li>Coordinate site needs, crews for scheduling, planning, and resources<\/li><li>Monitor forward-looking personnel requirements and vendor developments<\/li><li>Negotiate and manage client and vendor relationships<\/li><li>Approve appropriate invoices and proposal submissions<\/li><li>Assist Biz Dev &amp; Estimation Team with Pre-Bid site visits, analysis, and work plans for project proposals<\/li><\/ul>\n<p><strong>Essential Skills &amp; Knowledge<\/strong><\/p>\n<ul><li>Detailed understanding of civil and mining operations<\/li><li>General understanding of business leadership<\/li><li>Ability to oversee operational and organizational performance for mining projects<\/li><li>Solid understanding of financial and operational reporting<\/li><li>Ability to quantify and explain variances to owners and executives succinctly and clearly<\/li><li>Proficiency in civil and mining best practices to perform project management<\/li><li>Intelligent with demonstrated results from creativity<\/li><li>Willingness to learn what is takes to run growing and successful teams<\/li><li>Strong organizational, interpersonal, and written communication skill<\/li><li>Gifted person who can prioritize and balance competing initiatives and activities<\/li><li>Knack for continuous improvement of processes, solution-based issue resolution and outcomes<\/li><li>Organized, problem solver and solution developer, who can work with workers, engineers and owner teams<\/li><li>Believe in the power of culture with strong leadership qualities<\/li><\/ul>\n<p><strong>Benefits<\/strong><\/p>\n<p>Turner Mining Group offers a competitive salary, an excellent work culture, career advancement opportunities. Our team offers a benefits program which includes Medical, Dental, Vision, Life, and a 401k with company match. We believe in a work life balance and established a Paid Time Off policy as well as paid time off for major holidays.<\/p>\n<p>At Turner Mining Group, we encourage and celebrate an inclusive environment for all employees and are proud to be an equal opportunity workplace and affirmative action employer.<\/p>","%category%":"Operations","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/429732427df7-operations-superintendent","%breezy_id%":"429732427df7","%breezy_friendly_id%":"429732427df7-operations-superintendent","%breezy_created_date%":"2024-12-11T15:33:05.832Z","%breezy_updated_date%":"2025-10-17T14:57:00.918Z","%_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":2822,"infowindow_disable":false},{"source":"post","title":"Project Manager &#8211; Mining","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Project Manager &#8211; Mining\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Turner Mining Group &#8211;&nbsp;Project Manager&nbsp; A challenging and rewarding opportunity for a senior project manager with experience in the mining&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/project-manager-mining-3\/\" name=\"Project Manager &#8211; Mining\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Turner Mining Group &#8211;&nbsp;Project Manager&nbsp; A challenging and rewarding opportunity for a senior project manager with experience in the mining&hellip;","address":"Midland, TX, USA","location":{"lat":"31.9995797","city":"Midland","state":"TX","country":"United States","lng":"-102.0756701","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/project-manager-mining-3\/","zoom":19,"extra_fields":{"post_excerpt":"Turner Mining Group &#8211;&nbsp;Project Manager&nbsp; A challenging and rewarding opportunity for a senior project manager with experience in the mining&hellip;","post_content":"<p><strong><u>Turner Mining Group -&nbsp;Project Manager&nbsp;<\/u><\/strong><\/p>\n<p>A challenging and rewarding opportunity for a senior project manager with experience in the mining industry!<br><\/p>\n<p>We are looking for a talented Project Manager to lead the development and execution of a large-scale production mining projects. The Project Manager will be responsible for managing the project scope, schedule, budget, quality, safety, and stakeholder relations. The&nbsp;Project Manager&nbsp;will also oversee the engineering, procurement, construction, commissioning, and operation phases of the project.<\/p>\n<p><strong>Responsibilities:<\/strong><br><\/p>\n<ul><li>Develop and implement the project strategy, plan, and governance framework based on data analysis and best practices<\/li><li>Manage the project team and vendors using data-driven tools and metrics<\/li><li>Ensure the project meets the technical, regulatory, and environmental requirements using data validation and verification methods<\/li><li>Monitor and control the project performance, risks, issues, and changes using data visualization and reporting techniques<\/li><li>Report and communicate the project status, progress, and outcomes to the senior management and the client using data storytelling and presentation skills<\/li><li>Ensure the project adheres to the highest standards of health, safety, and quality using data collection and evaluation systems<\/li><li>Facilitate the smooth transition from construction to operation using data integration and automation solutions<\/li><\/ul>\n<p><strong>Qualifications:<\/strong><\/p>\n<ul><li>Bachelor's degree in engineering, project management, or related field<\/li><li>Minimum 10 years of experience in managing large-scale capital projects in the mining industry<\/li><li>Proven track record of delivering projects on time, on budget, and on quality using data-driven approaches<\/li><li>Strong leadership, communication, negotiation, and problem-solving skills with a data-oriented mindset<\/li><li>Ability to work effectively in a fast-paced and dynamic environment with data complexity and uncertainty<\/li><li>Familiarity with the frac sand market and the hydraulic fracturing process and the data sources and standards associated with them<\/li><li>Willingness to travel and relocate as required<\/li><\/ul>\n<p><strong>Benefits:<\/strong><\/p>\n<p>Our client offers a competitive salary, an excellent work culture, career advancement opportunities. Our client offers a benefits program which includes Medical, Dental, Vision, Life, and a 401k with company match.<\/p>\n<p>We encourage and celebrate an inclusive environment for all employees and are proud to be an equal opportunity workplace and affirmative action employer.<\/p>","post_title":"Project Manager &#8211; Mining","post_link":"https:\/\/turnerstaffing.com\/position\/project-manager-mining-3\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"","%location_country%":"United States","%location_city%":"Midland","%location_state_id%":"TX","%location_state_name%":"Texas","%location_city_state%":"Midland, TX","%education%":"","%department%":"Operations","%description%":"<p><strong><u>Turner Mining Group -&nbsp;Project Manager&nbsp;<\/u><\/strong><\/p>\n<p>A challenging and rewarding opportunity for a senior project manager with experience in the mining industry!<br><\/p>\n<p>We are looking for a talented Project Manager to lead the development and execution of a large-scale production mining projects. The Project Manager will be responsible for managing the project scope, schedule, budget, quality, safety, and stakeholder relations. The&nbsp;Project Manager&nbsp;will also oversee the engineering, procurement, construction, commissioning, and operation phases of the project.<\/p>\n<p><strong>Responsibilities:<\/strong><br><\/p>\n<ul><li>Develop and implement the project strategy, plan, and governance framework based on data analysis and best practices<\/li><li>Manage the project team and vendors using data-driven tools and metrics<\/li><li>Ensure the project meets the technical, regulatory, and environmental requirements using data validation and verification methods<\/li><li>Monitor and control the project performance, risks, issues, and changes using data visualization and reporting techniques<\/li><li>Report and communicate the project status, progress, and outcomes to the senior management and the client using data storytelling and presentation skills<\/li><li>Ensure the project adheres to the highest standards of health, safety, and quality using data collection and evaluation systems<\/li><li>Facilitate the smooth transition from construction to operation using data integration and automation solutions<\/li><\/ul>\n<p><strong>Qualifications:<\/strong><\/p>\n<ul><li>Bachelor's degree in engineering, project management, or related field<\/li><li>Minimum 10 years of experience in managing large-scale capital projects in the mining industry<\/li><li>Proven track record of delivering projects on time, on budget, and on quality using data-driven approaches<\/li><li>Strong leadership, communication, negotiation, and problem-solving skills with a data-oriented mindset<\/li><li>Ability to work effectively in a fast-paced and dynamic environment with data complexity and uncertainty<\/li><li>Familiarity with the frac sand market and the hydraulic fracturing process and the data sources and standards associated with them<\/li><li>Willingness to travel and relocate as required<\/li><\/ul>\n<p><strong>Benefits:<\/strong><\/p>\n<p>Our client offers a competitive salary, an excellent work culture, career advancement opportunities. Our client offers a benefits program which includes Medical, Dental, Vision, Life, and a 401k with company match.<\/p>\n<p>We encourage and celebrate an inclusive environment for all employees and are proud to be an equal opportunity workplace and affirmative action employer.<\/p>","%category%":"","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/c6399061e51d-project-manager-mining","%breezy_id%":"c6399061e51d","%breezy_friendly_id%":"c6399061e51d-project-manager-mining","%breezy_created_date%":"2023-12-19T13:34:24.180Z","%breezy_updated_date%":"2025-10-17T14:57:04.696Z","%_wpgmp_location_city%":"Midland","%_wpgmp_location_state%":"TX","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Midland, TX, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"31.9995797","%_wpgmp_metabox_longitude%":"-102.0756701","%rank_math_internal_links_processed%":"1"}},"id":2821,"infowindow_disable":false},{"source":"post","title":"Equipment Superintendent &#8211; Mining","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Equipment Superintendent &#8211; Mining\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Equipment Superintendent Job Description Manage Project maintenance and Equipment Vendor personnel Reports to Project Manager Safety Leadership Invest, teach, and&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/equipment-superintendent-mining\/\" name=\"Equipment Superintendent &#8211; Mining\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Equipment Superintendent Job Description Manage Project maintenance and Equipment Vendor personnel Reports to Project Manager Safety Leadership Invest, teach, and&hellip;","address":"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\/equipment-superintendent-mining\/","zoom":19,"extra_fields":{"post_excerpt":"Equipment Superintendent Job Description Manage Project maintenance and Equipment Vendor personnel Reports to Project Manager Safety Leadership Invest, teach, and&hellip;","post_content":"<p><strong>Equipment Superintendent Job Description<\/strong><\/p>\n<p><strong>Manage Project maintenance and Equipment Vendor personnel<\/strong><\/p>\n<p><strong>Reports to Project Manager<\/strong><\/p>\n<p><strong><u>Safety Leadership<\/u><\/strong><\/p>\n<ul><li>Invest, teach, and mentor project maintenance personnel to foster \"An Eye For Safety\u201d environment at the site<\/li><li>Mitigate onsite safety risks<\/li><li>Ensure all MSHA regulations are followed and maintain site safety standards<\/li><li>Conduct and participate in monthly site safety meetings to discuss incidents, safety trends, behavior goals, etc.<\/li><li>Ensure all workplace exams are complete and accurate<\/li><li>Task training is completed correctly and stored<\/li><li>Pre-operational inspection issues are corrected, and forms are filed according to the TMG process<\/li><li>All safety documents are filed and stored on-site<\/li><li>Follow the TMG process for incident investigation and response<\/li><li>Complete incident report in HCSS Safety<\/li><li>Provide employees with a safe and healthy work environment by providing safe systems of work, safe work procedures, adequate training and instruction, and competent supervision<\/li><li>Review hazard identification, near miss, and incident reports and provide follow-up as appropriate<\/li><li>Ensure maintenance employees and contractors working within the Site Project personnel are prequalified and have the necessary commencement paperwork, competencies, and qualifications to work safely and deliver quality maintenance services (has Stop Work Authority if standards are not met)<\/li><\/ul>\n<p><strong><u>Major Responsibilities<\/u><\/strong><\/p>\n<ul><li>Spend considerable time in the field interacting with the workforce \u2013 Creating&nbsp;<strong>\u201cvisible felt leadership\u201d<\/strong>&nbsp;~25 to 40% of working time<\/li><li>TMG fuel and lube technicians will report to the role<\/li><li>Manager equipment vendor maintenance personnel and coordinate their site activities<\/li><li>Develop systems and foster the required collaboration to ensure the department meets monthly targets<\/li><li>Review competencies, Scopes of Work, and Schedules of Rates for all Contractors, ensuring costs are managed and controlled while complying with Contractor Controls Policies and Procedures<\/li><li>Help develop maintenance strategy objectives and ensure they are met<\/li><li>Improve Equipment\/Operations Performance by Optimize Equipment &amp; Fleet Asset Reliability<\/li><li>Ensure the effective and efficient application of maintenance resources, as measured by schedule compliance, PM compliance, the level of planned vs. unplanned work, and the ongoing management of backlog<\/li><li>Create service requests, work orders, and purchase orders for repairs\/purchases in the TMG accounting systems and communicating with vendors during the purchase process<\/li><li>Assist Project Manager as needed with tracking maintenance costs and accounting<\/li><li>Participate in incident investigations (injury, high-potential, and equipment damage) to ensure that corrective actions are effectively implemented and tracked<\/li><li>Support the development and ongoing optimization of maintenance strategies for critical assets.<\/li><li>Complete performance evaluation reviews for direct reports and manage their career development.<\/li><li>Recruit for Maintenance positions. Ensure that succession planning for critical roles is in place<\/li><li>Ensure applicable maintenance training is provided as required<\/li><li>Communicate daily needs with Project team<\/li><li>Manage equipment costs, repairs, rebuilds, warrantee items, and equipment replacements<\/li><li>Manage field services for operations: service and mechanics trucks, tools, etc.<\/li><li>These responsibilities are required but not limited to and others may be assigned by the Project Manager as needed<\/li><\/ul>\n<p>Develop an equipment coordinator position if the need arises in the future<\/p>\n<p><\/p>\n<p><strong><u>Preferred Candidate Requirements:<\/u><\/strong><\/p>\n<ul><li>Minimum 5-7 years Maintenance General Foreman level or higher experience in heavy industry<\/li><li>Minimum of 4 years of management of the maintenance scheduling and workflow function<\/li><\/ul>\n<p><strong><u>Personnel Management<\/u><\/strong><\/p>\n<p>\u2022 Submit hiring requests\/termination requisitions to HR following the TMG process<\/p>\n<p>\u2022     Conduct interviews for maintenance employees<\/p>\n<p>\u2022     Complete employee reviews using the TMG form and submit them for approval<\/p>\n<p>\u2022     Evaluate maintenance personnel performance<\/p>\n<p>\u2022     Document employee issues\/ disciplinary action, send to Project Manager and HR<\/p>\n<p>\u2022&nbsp;&nbsp;&nbsp;&nbsp; Maintain complete knowledge of the employee handbook<\/p>\n<p><strong><u>Benefits<\/u><\/strong><\/p>\n<p>Turner Mining Group offers a competitive salary, an excellent work culture, and career advancement opportunities. Our team provides a benefits program which includes Medical, Dental, Vision, Life, and a 401k with company match.&nbsp; We believe in a work-life balance and have established paid time off for major holidays.<\/p>\n<p>At Turner Mining Group, we encourage and celebrate an inclusive environment for all employees and are proud to be an equal opportunity workplace and affirmative action employer<\/p>","post_title":"Equipment Superintendent &#8211; Mining","post_link":"https:\/\/turnerstaffing.com\/position\/equipment-superintendent-mining\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"","%location_country%":"United States","%location_city%":"Midland","%location_state_id%":"TX","%location_state_name%":"Texas","%location_city_state%":"Midland, TX","%education%":"","%department%":"","%description%":"<p><strong>Equipment Superintendent Job Description<\/strong><\/p>\n<p><strong>Manage Project maintenance and Equipment Vendor personnel<\/strong><\/p>\n<p><strong>Reports to Project Manager<\/strong><\/p>\n<p><strong><u>Safety Leadership<\/u><\/strong><\/p>\n<ul><li>Invest, teach, and mentor project maintenance personnel to foster \"An Eye For Safety\u201d environment at the site<\/li><li>Mitigate onsite safety risks<\/li><li>Ensure all MSHA regulations are followed and maintain site safety standards<\/li><li>Conduct and participate in monthly site safety meetings to discuss incidents, safety trends, behavior goals, etc.<\/li><li>Ensure all workplace exams are complete and accurate<\/li><li>Task training is completed correctly and stored<\/li><li>Pre-operational inspection issues are corrected, and forms are filed according to the TMG process<\/li><li>All safety documents are filed and stored on-site<\/li><li>Follow the TMG process for incident investigation and response<\/li><li>Complete incident report in HCSS Safety<\/li><li>Provide employees with a safe and healthy work environment by providing safe systems of work, safe work procedures, adequate training and instruction, and competent supervision<\/li><li>Review hazard identification, near miss, and incident reports and provide follow-up as appropriate<\/li><li>Ensure maintenance employees and contractors working within the Site Project personnel are prequalified and have the necessary commencement paperwork, competencies, and qualifications to work safely and deliver quality maintenance services (has Stop Work Authority if standards are not met)<\/li><\/ul>\n<p><strong><u>Major Responsibilities<\/u><\/strong><\/p>\n<ul><li>Spend considerable time in the field interacting with the workforce \u2013 Creating&nbsp;<strong>\u201cvisible felt leadership\u201d<\/strong>&nbsp;~25 to 40% of working time<\/li><li>TMG fuel and lube technicians will report to the role<\/li><li>Manager equipment vendor maintenance personnel and coordinate their site activities<\/li><li>Develop systems and foster the required collaboration to ensure the department meets monthly targets<\/li><li>Review competencies, Scopes of Work, and Schedules of Rates for all Contractors, ensuring costs are managed and controlled while complying with Contractor Controls Policies and Procedures<\/li><li>Help develop maintenance strategy objectives and ensure they are met<\/li><li>Improve Equipment\/Operations Performance by Optimize Equipment &amp; Fleet Asset Reliability<\/li><li>Ensure the effective and efficient application of maintenance resources, as measured by schedule compliance, PM compliance, the level of planned vs. unplanned work, and the ongoing management of backlog<\/li><li>Create service requests, work orders, and purchase orders for repairs\/purchases in the TMG accounting systems and communicating with vendors during the purchase process<\/li><li>Assist Project Manager as needed with tracking maintenance costs and accounting<\/li><li>Participate in incident investigations (injury, high-potential, and equipment damage) to ensure that corrective actions are effectively implemented and tracked<\/li><li>Support the development and ongoing optimization of maintenance strategies for critical assets.<\/li><li>Complete performance evaluation reviews for direct reports and manage their career development.<\/li><li>Recruit for Maintenance positions. Ensure that succession planning for critical roles is in place<\/li><li>Ensure applicable maintenance training is provided as required<\/li><li>Communicate daily needs with Project team<\/li><li>Manage equipment costs, repairs, rebuilds, warrantee items, and equipment replacements<\/li><li>Manage field services for operations: service and mechanics trucks, tools, etc.<\/li><li>These responsibilities are required but not limited to and others may be assigned by the Project Manager as needed<\/li><\/ul>\n<p>Develop an equipment coordinator position if the need arises in the future<\/p>\n<p><\/p>\n<p><strong><u>Preferred Candidate Requirements:<\/u><\/strong><\/p>\n<ul><li>Minimum 5-7 years Maintenance General Foreman level or higher experience in heavy industry<\/li><li>Minimum of 4 years of management of the maintenance scheduling and workflow function<\/li><\/ul>\n<p><strong><u>Personnel Management<\/u><\/strong><\/p>\n<p>\u2022 Submit hiring requests\/termination requisitions to HR following the TMG process<\/p>\n<p>\u2022     Conduct interviews for maintenance employees<\/p>\n<p>\u2022     Complete employee reviews using the TMG form and submit them for approval<\/p>\n<p>\u2022     Evaluate maintenance personnel performance<\/p>\n<p>\u2022     Document employee issues\/ disciplinary action, send to Project Manager and HR<\/p>\n<p>\u2022&nbsp;&nbsp;&nbsp;&nbsp; Maintain complete knowledge of the employee handbook<\/p>\n<p><strong><u>Benefits<\/u><\/strong><\/p>\n<p>Turner Mining Group offers a competitive salary, an excellent work culture, and career advancement opportunities. Our team provides a benefits program which includes Medical, Dental, Vision, Life, and a 401k with company match.&nbsp; We believe in a work-life balance and have established paid time off for major holidays.<\/p>\n<p>At Turner Mining Group, we encourage and celebrate an inclusive environment for all employees and are proud to be an equal opportunity workplace and affirmative action employer<\/p>","%category%":"Operations","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/53014a57f4f6-equipment-superintendent-mining","%breezy_id%":"53014a57f4f6","%breezy_friendly_id%":"53014a57f4f6-equipment-superintendent-mining","%breezy_created_date%":"2022-10-04T21:05:22.026Z","%breezy_updated_date%":"2025-10-13T17:56:36.040Z","%_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":2820,"infowindow_disable":false},{"source":"post","title":"Industrial Electrician- Oil &amp; Gas","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Industrial Electrician- Oil &amp; Gas\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Job Description: We are seeking a skilled and dedicated Oil &amp; Gas Electrician to join our team. The ideal candidate&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/industrial-electrician-oil-gas\/\" name=\"Industrial Electrician- Oil &amp; Gas\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Job Description: We are seeking a skilled and dedicated Oil &amp; Gas Electrician to join our team. The ideal candidate&hellip;","address":"Wyalusing, PA, USA","location":{"lat":"41.6681309","city":"Wyalusing","state":"PA","country":"United States","lng":"-76.2618786","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/industrial-electrician-oil-gas\/","zoom":19,"extra_fields":{"post_excerpt":"Job Description: We are seeking a skilled and dedicated Oil &amp; Gas Electrician to join our team. The ideal candidate&hellip;","post_content":"<p>Job Description:<\/p>\n<p>We are seeking a skilled and dedicated Oil &amp; Gas Electrician to join our team. The ideal<\/p>\n<p>candidate will have a strong work ethic, attention to detail and the ability to work well in<\/p>\n<p>a team-oriented environment.<\/p>\n<p>Responsibilities:<\/p>\n<p>- Install, maintain, and repair electrical systems in Oil &amp; Gas and Industrial settings.<\/p>\n<p>- Bend and Install Conduit - Install Rigid Conduit<\/p>\n<p>- Install Electric Heat Trace<\/p>\n<p>- Install Cable Tray<\/p>\n<p>- Install and Terminate Wiring for Devices<\/p>\n<p>- Willing to work 60 Hours Per Week<\/p>\n<p>- Ensure all work is performed in accordance with relevant codes and safety standards.<\/p>\n<p>- Troubleshoot electrical issues and perform necessary repairs.<\/p>\n<p>- Collaborate with team members to complete projects efficiently and effectively.<\/p>\n<p>- Maintain a clean and organized work area.<\/p>\n<p>- Provide exceptional customer service and maintain positive client relationships.<\/p>\n<p>Qualifications:<\/p>\n<p>- Valid driver's license required<\/p>\n<p>- Minimum Two Years of Electrical experience in the Oil &amp; Gas Field<\/p>\n<p>- Proven experience as a commercial or industrial electrician<\/p>\n<p>- Strong understanding of electrical systems and safety procedures<\/p>\n<p>- Excellent problem-solving skills and attention to detail<\/p>\n<p>- Ability to work independently and as part of a team<\/p>\n<p>- Trustworthy, reliable and takes pride in their work<\/p>\n<p>- Positive attitude and the ability to fit into our company culture<\/p>","post_title":"Industrial Electrician- Oil &amp; Gas","post_link":"https:\/\/turnerstaffing.com\/position\/industrial-electrician-oil-gas\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Mid Level","%location_country%":"United States","%location_city%":"Wyalusing","%location_state_id%":"PA","%location_state_name%":"Pennsylvania","%location_city_state%":"Wyalusing, PA","%education%":"Unspecified","%department%":"","%description%":"<p>Job Description:<\/p>\n<p>We are seeking a skilled and dedicated Oil &amp; Gas Electrician to join our team. The ideal<\/p>\n<p>candidate will have a strong work ethic, attention to detail and the ability to work well in<\/p>\n<p>a team-oriented environment.<\/p>\n<p>Responsibilities:<\/p>\n<p>- Install, maintain, and repair electrical systems in Oil &amp; Gas and Industrial settings.<\/p>\n<p>- Bend and Install Conduit - Install Rigid Conduit<\/p>\n<p>- Install Electric Heat Trace<\/p>\n<p>- Install Cable Tray<\/p>\n<p>- Install and Terminate Wiring for Devices<\/p>\n<p>- Willing to work 60 Hours Per Week<\/p>\n<p>- Ensure all work is performed in accordance with relevant codes and safety standards.<\/p>\n<p>- Troubleshoot electrical issues and perform necessary repairs.<\/p>\n<p>- Collaborate with team members to complete projects efficiently and effectively.<\/p>\n<p>- Maintain a clean and organized work area.<\/p>\n<p>- Provide exceptional customer service and maintain positive client relationships.<\/p>\n<p>Qualifications:<\/p>\n<p>- Valid driver's license required<\/p>\n<p>- Minimum Two Years of Electrical experience in the Oil &amp; Gas Field<\/p>\n<p>- Proven experience as a commercial or industrial electrician<\/p>\n<p>- Strong understanding of electrical systems and safety procedures<\/p>\n<p>- Excellent problem-solving skills and attention to detail<\/p>\n<p>- Ability to work independently and as part of a team<\/p>\n<p>- Trustworthy, reliable and takes pride in their work<\/p>\n<p>- Positive attitude and the ability to fit into our company culture<\/p>","%category%":"Operations","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/19a197bb5459-industrial-electrician-oil-gas","%breezy_id%":"19a197bb5459","%breezy_friendly_id%":"19a197bb5459-industrial-electrician-oil-gas","%breezy_created_date%":"2025-10-09T17:11:19.014Z","%breezy_updated_date%":"2025-10-09T17:12:18.210Z","%_wpgmp_location_city%":"Wyalusing","%_wpgmp_location_state%":"PA","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Wyalusing, PA, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"41.6681309","%_wpgmp_metabox_longitude%":"-76.2618786","%rank_math_internal_links_processed%":"1"}},"id":2816,"infowindow_disable":false},{"source":"post","title":"Civil Construction Superintendent","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Civil Construction Superintendent\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    The General Superintendent manages all civil construction projects and oversees their progress along the way in a timely and cost-effective&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/civil-construction-superintendent\/\" name=\"Civil Construction Superintendent\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"The General Superintendent manages all civil construction projects and oversees their progress along the way in a timely and cost-effective&hellip;","address":"Old Lyme, CT, USA","location":{"lat":"41.3162037","city":"Old Lyme","state":"CT","country":"United States","lng":"-72.329796","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/civil-construction-superintendent\/","zoom":19,"extra_fields":{"post_excerpt":"The General Superintendent manages all civil construction projects and oversees their progress along the way in a timely and cost-effective&hellip;","post_content":"<p>The General Superintendent manages all civil construction projects and oversees their progress along the way in a timely and cost-effective manner. You will be responsible for budgeting, organization, implementation and scheduling of the projects.<\/p>\n<p><strong>Duties and responsibilities<\/strong><\/p>\n<ul><li>Oversee and direct civil construction projects from conception to completion<\/li><li>Review the project in-depth to schedule deliverables and estimate costs<\/li><li>Oversee all onsite and offsite civil construction projects to monitor compliance with building and safety regulations<\/li><li>Coordinate and direct construction workers and subcontractors<\/li><li>Select tools, materials and equipment and track inventory<\/li><li>Oversee and schedule manpower on multiple sites<\/li><li>Meet contractual conditions of performance<\/li><li>Review the work progress on daily basis<\/li><li>Prepare internal and external reports pertaining to job status<\/li><li>Plan ahead to prevent problems and resolve any emerging ones<\/li><li>Negotiate terms of purchasing agreements coordinate material delivery with Project manager<\/li><li>Analyze, manage and mitigate risks<\/li><li>Ensure quality construction standards and the use of proper construction techniques<\/li><li>Communicate project status and schedule to the office for proper planning<\/li><\/ul>\n<p><strong>Qualifications<\/strong><\/p>\n<ul><li>Proven working experience in civil construction management<\/li><li>Advanced knowledge of civil construction management processes, means and methods<\/li><li>Expert knowledge of building products, civil construction details and relevant rules, regulations and quality standards<\/li><li>Understanding of all facets of the civil construction process<\/li><li>Familiarity with civil construction management software packages<\/li><li>Ability to plan and see the \u201cbig picture\u201d<\/li><li>Competent in conflict and crisis management<\/li><li>Leadership and human resources management skills<\/li><li>Excellent time and project management skills<\/li><li>BS degree in construction management, architecture, engineering or related field<\/li><li>Travel is required for onsite meetings and daily coordination<\/li><\/ul>","post_title":"Civil Construction Superintendent","post_link":"https:\/\/turnerstaffing.com\/position\/civil-construction-superintendent\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"","%location_country%":"United States","%location_city%":"Old Lyme","%location_state_id%":"CT","%location_state_name%":"Connecticut","%location_city_state%":"Old Lyme, CT","%education%":"","%department%":"","%description%":"<p>The General Superintendent manages all civil construction projects and oversees their progress along the way in a timely and cost-effective manner. You will be responsible for budgeting, organization, implementation and scheduling of the projects.<\/p>\n<p><strong>Duties and responsibilities<\/strong><\/p>\n<ul><li>Oversee and direct civil construction projects from conception to completion<\/li><li>Review the project in-depth to schedule deliverables and estimate costs<\/li><li>Oversee all onsite and offsite civil construction projects to monitor compliance with building and safety regulations<\/li><li>Coordinate and direct construction workers and subcontractors<\/li><li>Select tools, materials and equipment and track inventory<\/li><li>Oversee and schedule manpower on multiple sites<\/li><li>Meet contractual conditions of performance<\/li><li>Review the work progress on daily basis<\/li><li>Prepare internal and external reports pertaining to job status<\/li><li>Plan ahead to prevent problems and resolve any emerging ones<\/li><li>Negotiate terms of purchasing agreements coordinate material delivery with Project manager<\/li><li>Analyze, manage and mitigate risks<\/li><li>Ensure quality construction standards and the use of proper construction techniques<\/li><li>Communicate project status and schedule to the office for proper planning<\/li><\/ul>\n<p><strong>Qualifications<\/strong><\/p>\n<ul><li>Proven working experience in civil construction management<\/li><li>Advanced knowledge of civil construction management processes, means and methods<\/li><li>Expert knowledge of building products, civil construction details and relevant rules, regulations and quality standards<\/li><li>Understanding of all facets of the civil construction process<\/li><li>Familiarity with civil construction management software packages<\/li><li>Ability to plan and see the \u201cbig picture\u201d<\/li><li>Competent in conflict and crisis management<\/li><li>Leadership and human resources management skills<\/li><li>Excellent time and project management skills<\/li><li>BS degree in construction management, architecture, engineering or related field<\/li><li>Travel is required for onsite meetings and daily coordination<\/li><\/ul>","%category%":"Operations","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/8e26a6221060-civil-construction-superintendent","%breezy_id%":"8e26a6221060","%breezy_friendly_id%":"8e26a6221060-civil-construction-superintendent","%breezy_created_date%":"2025-10-07T17:35:29.452Z","%breezy_updated_date%":"2025-10-07T17:40:06.795Z","%_wpgmp_location_city%":"Old Lyme","%_wpgmp_location_state%":"CT","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Old Lyme, CT, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"41.3162037","%_wpgmp_metabox_longitude%":"-72.329796","%rank_math_internal_links_processed%":"1"}},"id":2813,"infowindow_disable":false},{"source":"post","title":"Project Manager","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Project Manager\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Busy heavy civil site construction company is looking for an experienced Project Manager. The ideal candidate should have at least&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/project-manager-2\/\" name=\"Project Manager\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Busy heavy civil site construction company is looking for an experienced Project Manager. The ideal candidate should have at least&hellip;","address":"Old Lyme, CT, USA","location":{"lat":"41.3162037","city":"Old Lyme","state":"CT","country":"United States","lng":"-72.329796","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/project-manager-2\/","zoom":19,"extra_fields":{"post_excerpt":"Busy heavy civil site construction company is looking for an experienced Project Manager. The ideal candidate should have at least&hellip;","post_content":"<p><\/p><p>Busy heavy civil site construction company is looking for an experienced Project Manager. The ideal candidate should have at least 3 years experience in heavy civil site construction project management, and have experience working with the CT DOT.<\/p>\n<p><strong>Responsibilities Include:<\/strong><\/p>\n<ul><li>Collaborate with engineers, architects, CMs<\/li><li>Determine needed resources i.e. manpower, equipment, and materials<\/li><li>Obtain permits<\/li><li>Maintain project schedules<\/li><li>Preparation of purchase orders<\/li><li>Prepare and review submittals and shop drawings<\/li><li>Project organization<\/li><li>Request RFIs<\/li><li>Coordinate submittals by other trades<\/li><li>Project Closeout<\/li><li>Track punch list and ensure items are complete<\/li><\/ul>\n<p><strong>Qualifications:<\/strong><\/p>\n<ul><li>3-5 years of relevant experience<\/li><li>Knowledge of CT DOT submittal process<\/li><li>Proficiency with blueprint reading and mechanical drawings<\/li><li>Able to perform take-offs, measuring, and provide material lists<\/li><li>Degree in civil, architecture, mechanical engineering, building construction, or related field preferred but not required<\/li><li>Strong interpersonal, communication and writing skills, extreme attention to detail and ability to manage multiple tasks<\/li><li>MS Office experience required<\/li><\/ul><p><\/p>","post_title":"Project Manager","post_link":"https:\/\/turnerstaffing.com\/position\/project-manager-2\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"","%location_country%":"United States","%location_city%":"Old Lyme","%location_state_id%":"CT","%location_state_name%":"Connecticut","%location_city_state%":"Old Lyme, CT","%education%":"","%department%":"","%description%":"<p><\/p><p>Busy heavy civil site construction company is looking for an experienced Project Manager. The ideal candidate should have at least 3 years experience in heavy civil site construction project management, and have experience working with the CT DOT.<\/p>\n<p><strong>Responsibilities Include:<\/strong><\/p>\n<ul><li>Collaborate with engineers, architects, CMs<\/li><li>Determine needed resources i.e. manpower, equipment, and materials<\/li><li>Obtain permits<\/li><li>Maintain project schedules<\/li><li>Preparation of purchase orders<\/li><li>Prepare and review submittals and shop drawings<\/li><li>Project organization<\/li><li>Request RFIs<\/li><li>Coordinate submittals by other trades<\/li><li>Project Closeout<\/li><li>Track punch list and ensure items are complete<\/li><\/ul>\n<p><strong>Qualifications:<\/strong><\/p>\n<ul><li>3-5 years of relevant experience<\/li><li>Knowledge of CT DOT submittal process<\/li><li>Proficiency with blueprint reading and mechanical drawings<\/li><li>Able to perform take-offs, measuring, and provide material lists<\/li><li>Degree in civil, architecture, mechanical engineering, building construction, or related field preferred but not required<\/li><li>Strong interpersonal, communication and writing skills, extreme attention to detail and ability to manage multiple tasks<\/li><li>MS Office experience required<\/li><\/ul><p><\/p>","%category%":"Operations","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/be06afab5bf4-project-manager","%breezy_id%":"be06afab5bf4","%breezy_friendly_id%":"be06afab5bf4-project-manager","%breezy_created_date%":"2025-10-07T17:44:26.016Z","%breezy_updated_date%":"2025-10-07T17:46:31.899Z","%_wpgmp_location_city%":"Old Lyme","%_wpgmp_location_state%":"CT","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Old Lyme, CT, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"41.3162037","%_wpgmp_metabox_longitude%":"-72.329796","%rank_math_internal_links_processed%":"1"}},"id":2814,"infowindow_disable":false},{"source":"post","title":"Service Operations Manager","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Service Operations Manager\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    WHAT YOU\u2019LL DO \u2022 Lead, mentor, and develop the service operations team. \u2022 Set clear performance goals, KPIs, and service&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/service-operations-manager\/\" name=\"Service Operations Manager\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"WHAT YOU\u2019LL DO \u2022 Lead, mentor, and develop the service operations team. \u2022 Set clear performance goals, KPIs, and service&hellip;","address":"St. Martin, MN, USA","location":{"lat":"45.5019088","city":"St. Martin","state":"MN","country":"United States","lng":"-94.6688941","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/service-operations-manager\/","zoom":19,"extra_fields":{"post_excerpt":"WHAT YOU\u2019LL DO \u2022 Lead, mentor, and develop the service operations team. \u2022 Set clear performance goals, KPIs, and service&hellip;","post_content":"<p>WHAT YOU\u2019LL DO<\/p>\n<p>\u2022 Lead, mentor, and develop the service operations team.<\/p>\n\n<p>\u2022 Set clear performance goals, KPIs, and service standards (SLAs).<\/p>\n\n<p>\u2022 Partner with sales, technicians, engineering, and parts to deliver seamless customer support.<\/p>\n\n<p>\u2022 Oversee scheduling, escalation paths, warranty claims, and preventive maintenance.<\/p>\n\n<p>\u2022 Optimize processes using Lean\/Six Sigma principles to improve efficiency.<\/p>\n\n<p>\u2022 Ensure accurate reporting and insights through CRM\/ERP\/service tools.<\/p>\n\n<p>\u2022&nbsp;Champion the Voice of the Customer in leadership discussions.<\/p>\n\n<p>\u2022 Leverage new technologies (remote diagnostics, predictive tools) to enhance uptime and service quality.<\/p>\n\n<p>\u2022 Ability to travel 10-15% of the time, for customer site visits.<\/p>\n\n<p>QUALIFICATIONS<\/p>\n<p>\u2022 Bachelor\u2019s degree in business, engineering, or related field or equivalent experience.<\/p>\n\n<p>\u2022 6+ years of service operations leadership in heavy equipment, OEM, industrial, or automotive industries.<\/p>\n\n<p>\u2022 Experience managing both onsite and remote teams.<\/p>\n\n<p>\u2022 Strong process improvement skills (Lean, Six Sigma preferred).<\/p>\n\n<p>\u2022 Expertise with CRM, ERP, and service management systems.<\/p>\n\n<p>\u2022 Excellent leadership, communication, and problem-solving skills.<\/p>\n\n<p>\u2022 Customer-first mindset with a focus on minimizing downtime and maximizing satisfaction.<\/p>","post_title":"Service Operations Manager","post_link":"https:\/\/turnerstaffing.com\/position\/service-operations-manager\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Mid Level","%location_country%":"United States","%location_city%":"St. Martin","%location_state_id%":"MN","%location_state_name%":"Minnesota","%location_city_state%":"St. Martin, MN","%education%":"Bachelor's Degree","%department%":"","%description%":"<p>WHAT YOU\u2019LL DO<\/p>\n<p>\u2022 Lead, mentor, and develop the service operations team.<\/p>\n\n<p>\u2022 Set clear performance goals, KPIs, and service standards (SLAs).<\/p>\n\n<p>\u2022 Partner with sales, technicians, engineering, and parts to deliver seamless customer support.<\/p>\n\n<p>\u2022 Oversee scheduling, escalation paths, warranty claims, and preventive maintenance.<\/p>\n\n<p>\u2022 Optimize processes using Lean\/Six Sigma principles to improve efficiency.<\/p>\n\n<p>\u2022 Ensure accurate reporting and insights through CRM\/ERP\/service tools.<\/p>\n\n<p>\u2022&nbsp;Champion the Voice of the Customer in leadership discussions.<\/p>\n\n<p>\u2022 Leverage new technologies (remote diagnostics, predictive tools) to enhance uptime and service quality.<\/p>\n\n<p>\u2022 Ability to travel 10-15% of the time, for customer site visits.<\/p>\n\n<p>QUALIFICATIONS<\/p>\n<p>\u2022 Bachelor\u2019s degree in business, engineering, or related field or equivalent experience.<\/p>\n\n<p>\u2022 6+ years of service operations leadership in heavy equipment, OEM, industrial, or automotive industries.<\/p>\n\n<p>\u2022 Experience managing both onsite and remote teams.<\/p>\n\n<p>\u2022 Strong process improvement skills (Lean, Six Sigma preferred).<\/p>\n\n<p>\u2022 Expertise with CRM, ERP, and service management systems.<\/p>\n\n<p>\u2022 Excellent leadership, communication, and problem-solving skills.<\/p>\n\n<p>\u2022 Customer-first mindset with a focus on minimizing downtime and maximizing satisfaction.<\/p>","%category%":"Operations","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/6507244dfcaf-service-operations-manager","%breezy_id%":"6507244dfcaf","%breezy_friendly_id%":"6507244dfcaf-service-operations-manager","%breezy_created_date%":"2025-10-07T20:28:21.902Z","%breezy_updated_date%":"2025-10-07T20:29:23.409Z","%_wpgmp_location_city%":"St. Martin","%_wpgmp_location_state%":"MN","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"St. Martin, MN, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"45.5019088","%_wpgmp_metabox_longitude%":"-94.6688941","%rank_math_internal_links_processed%":"1"}},"id":2815,"infowindow_disable":false},{"source":"post","title":"Haul Truck Operator (CAT 777)","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Haul Truck Operator (CAT 777)\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Job Title:&nbsp;Haul Truck Driver Company:&nbsp;Copper Mining Company (Partnered with Turner Staffing Group) Location: Ruth, NV Position Type:&nbsp;Full-Time About Us:&nbsp;Turner Staffing&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/haul-truck-operator-cat-777\/\" name=\"Haul Truck Operator (CAT 777)\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Job Title:&nbsp;Haul Truck Driver Company:&nbsp;Copper Mining Company (Partnered with Turner Staffing Group) Location: Ruth, NV Position Type:&nbsp;Full-Time About Us:&nbsp;Turner Staffing&hellip;","address":"Ely, NV, USA","location":{"lat":"39.2533328","city":"Ely","state":"NV","country":"United States","lng":"-114.874248","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/haul-truck-operator-cat-777\/","zoom":19,"extra_fields":{"post_excerpt":"Job Title:&nbsp;Haul Truck Driver Company:&nbsp;Copper Mining Company (Partnered with Turner Staffing Group) Location: Ruth, NV Position Type:&nbsp;Full-Time About Us:&nbsp;Turner Staffing&hellip;","post_content":"<p><strong>Job Title:<\/strong>&nbsp;Haul Truck Driver<\/p>\n<p><strong>Company:<\/strong>&nbsp;Copper Mining Company (Partnered with Turner Staffing Group)<\/p>\n<p><strong>Location: Ruth, NV<\/strong><\/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 Copper Mining Company in Nevada, 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 copper ore and other materials. 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 copper ore and other 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 Haul Truck Driver in a mining or heavy equipment environment.<\/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>Education and Certifications:<\/strong><\/p>\n<ul><li>High school diploma or equivalent.<\/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><li>Paid time off and holidays<\/li><\/ul>","post_title":"Haul Truck Operator (CAT 777)","post_link":"https:\/\/turnerstaffing.com\/position\/haul-truck-operator-cat-777\/","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;Haul Truck Driver<\/p>\n<p><strong>Company:<\/strong>&nbsp;Copper Mining Company (Partnered with Turner Staffing Group)<\/p>\n<p><strong>Location: Ruth, NV<\/strong><\/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 Copper Mining Company in Nevada, 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 copper ore and other materials. 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 copper ore and other 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 Haul Truck Driver in a mining or heavy equipment environment.<\/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>Education and Certifications:<\/strong><\/p>\n<ul><li>High school diploma or equivalent.<\/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><li>Paid time off and holidays<\/li><\/ul>","%category%":"Operations","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/5784a41e4da9-haul-truck-operator-cat-777","%breezy_id%":"5784a41e4da9","%breezy_friendly_id%":"5784a41e4da9-haul-truck-operator-cat-777","%breezy_created_date%":"2024-05-14T14:35:55.890Z","%breezy_updated_date%":"2025-10-03T19:45:13.639Z","%_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":2812,"infowindow_disable":false},{"source":"post","title":"Safety Support Specialist","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Safety Support Specialist\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Safety Support Specialist Reports to:&nbsp;Director of Safety \u2013 Turner Mining Group Job Description: The Safety Support Specialist is responsible for&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/safety-support-specialist-2\/\" name=\"Safety Support Specialist\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Safety Support Specialist Reports to:&nbsp;Director of Safety \u2013 Turner Mining Group Job Description: The Safety Support Specialist is responsible for&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\/safety-support-specialist-2\/","zoom":19,"extra_fields":{"post_excerpt":"Safety Support Specialist Reports to:&nbsp;Director of Safety \u2013 Turner Mining Group Job Description: The Safety Support Specialist is responsible for&hellip;","post_content":"<p><strong><u>Safety Support Specialist<\/u><\/strong><\/p>\n<p><strong>Reports to:<\/strong>&nbsp;Director of Safety \u2013 Turner Mining Group<\/p>\n<p><strong>Job Description:<\/strong><\/p>\n<p>The Safety Support Specialist is responsible for assisting with development, implementation, and<\/p>\n<p>oversight of our comprehensive safety program, ensuring compliance with all applicable regulatory<\/p>\n<p>requirements, and fostering a culture of safe operation within the organization. The Safety Support<\/p>\n<p>Specialist provides support and guidance for the Turner Mining Group projects&nbsp;while influencing employees to create safety<\/p>\n<p>ownership across all levels of the organization. The successful candidate must live the values and<\/p>\n<p>be an outward example to others. (An eye for Safety, and Attitude for Excellence, a mind for<\/p>\n<p>innovation, and a heart for people)<\/p>\n<p><\/p>\n<p><strong>Objectives and Contributions:<\/strong><\/p>\n<p>The Safety Support Specialist is focused on key aspects that drive wholistic safety ownership at a<\/p>\n<p>personal level. Many safety programs follow rigid requirements that are designed to \u201cthink\u201d for the<\/p>\n<p>employees. At Turner, we want to think outside the box. The key to a successful safety program is<\/p>\n<p>employee engagement, participation, and buy in.<\/p>\n<ul><li>Work directly with site leadership to ensure consistent use of systems, programs, and processes.<\/li><li>Support building a culture of Safe Production<\/li><li>Work with employees to ensure a high level of accuracy and engagement on hazard identification and control<strong>&nbsp;(Critical)<\/strong><\/li><li>Engage crews and leadership to define processes that motivate working towards common goals<\/li><li>Conduct and assist in managing Hearing Conservation testing under CAOHC Certification<\/li><li>Conduct and assist in managing Industrial Hygiene testing focused primarily on noise and dust exposure.<\/li><li>Assist with MSHA regulatory training and verify compliance to standards.<\/li><li>Live the values as part of a visible daily decision-making process<\/li><li>Audit sites while focusing on conditions and behaviors that reflect our desire to be the best in the business.<\/li><li>Assist in problem-solving including incident investigations, root cause analysis, and corrective action development.<\/li><li>Learn and assist with key performance indicators, company targets, and progress reporting.<\/li><li>Assist with and lead crew \/ supervision development opportunities.<\/li><li>Assist with client specific safety needs as required.<\/li><li>Support risk assessment processes at various levels of the organization including field level risk, project-based risk, and organizational risk management.<\/li><\/ul>\n<p><strong>Culture and Communication:<\/strong><\/p>\n<ul><li>Foster excitement throughout the organization by taking safety to new heights through cutting edge ideas and tactics.<\/li><li>Assist with site milestone recognition programs.<\/li><li>Assist with site communication programs and processes to ensure timely, specific, and value-added information.<\/li><li>Partner with site and project leaders to identify areas of improvement.<\/li><li>Develop and implement processes to reduce and eliminate repeat incidents<\/li><li>Assist site leaders with quality safety toolbox talks<\/li><li>Work with crews to support proactive near miss reporting.<\/li><li>Be visible with site leadership and crews. Spend time with Operations, Maintenance, and Site<\/li><li>Supervision to build relationships and develop trust.<\/li><\/ul>\n<p><strong>Systems:<\/strong><\/p>\n<ul><li>Support safety documentation platforms including HCSS, SharePoint, Adobe, and regulatory required systems.<\/li><li>Support incident tracking processes.<\/li><li>Ensure consistent use of root cause methodology<\/li><li>Implementation and use of risk analysis tools evaluating business processes and task-based risks<\/li><\/ul>\n<p><strong>Processes:<\/strong><\/p>\n<ul><li>Assist with leading and lagging indicators across the sites.<\/li><li>Work with leaders to develop ideas and improvement opportunities<\/li><li>Participate and support new project kick off requirements as well as closing other sites \/ projects.<\/li><li>Stay current with industry trends, regulations, and best practices in safety management, and recommend updates to company policies and procedures as needed.<\/li><li>Assist in writing and updating policies \/ procedures \/ and work instructions using professional writing language.<\/li><\/ul>\n<p><strong>Time and Interactions:<\/strong><\/p>\n<ul><li>This Safety Support Specialist role is based in Ely, NV<\/li><li>This role is designed to be site based, however travel may be required.<\/li><li>The successful candidate will be self-starting, motivated, with a strong desire to be part of a team and to influence improvement.<\/li><li>Communication is also critical to keep leadership and site-based personnel in the loop of successes, challenges, and any additional support that may be required. Building credibility is key with the sites and supporting their safety needs.<\/li><\/ul>\n<p><strong>Qualifications:<\/strong><\/p>\n<ul><li>Microsoft Office proficiency<\/li><li>Must be motivated to look for site \/ crew \/ system improvement opportunities- Required<\/li><li>Proficiency in safety data and use of safety systems \u2013 Preferred<\/li><li>Ability to learn in a fast-paced environment - Required<\/li><li>Understanding of OSHA \/ MSHA regulatory requirements - Blue Card certification preferred<\/li><li>Bachelor\u2019s degree in occupational safety and health or equivalent preferred<\/li><li>3-8 years\u2019 experience in mining \/ heavy industry preferred<\/li><li>Working knowledge of safety systems and processes<\/li><li>Proficiency in written presentations and processes<\/li><li>Appropriate attention to detail required<\/li><li>The successful candidate must be passionate about their role and the success of Turner Mining Group.<\/li><\/ul>","post_title":"Safety Support Specialist","post_link":"https:\/\/turnerstaffing.com\/position\/safety-support-specialist-2\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Associate","%location_country%":"United States","%location_city%":"Ely","%location_state_id%":"NV","%location_state_name%":"Nevada","%location_city_state%":"Ely, NV","%education%":"Unspecified","%department%":"Safety","%description%":"<p><strong><u>Safety Support Specialist<\/u><\/strong><\/p>\n<p><strong>Reports to:<\/strong>&nbsp;Director of Safety \u2013 Turner Mining Group<\/p>\n<p><strong>Job Description:<\/strong><\/p>\n<p>The Safety Support Specialist is responsible for assisting with development, implementation, and<\/p>\n<p>oversight of our comprehensive safety program, ensuring compliance with all applicable regulatory<\/p>\n<p>requirements, and fostering a culture of safe operation within the organization. The Safety Support<\/p>\n<p>Specialist provides support and guidance for the Turner Mining Group projects&nbsp;while influencing employees to create safety<\/p>\n<p>ownership across all levels of the organization. The successful candidate must live the values and<\/p>\n<p>be an outward example to others. (An eye for Safety, and Attitude for Excellence, a mind for<\/p>\n<p>innovation, and a heart for people)<\/p>\n<p><\/p>\n<p><strong>Objectives and Contributions:<\/strong><\/p>\n<p>The Safety Support Specialist is focused on key aspects that drive wholistic safety ownership at a<\/p>\n<p>personal level. Many safety programs follow rigid requirements that are designed to \u201cthink\u201d for the<\/p>\n<p>employees. At Turner, we want to think outside the box. The key to a successful safety program is<\/p>\n<p>employee engagement, participation, and buy in.<\/p>\n<ul><li>Work directly with site leadership to ensure consistent use of systems, programs, and processes.<\/li><li>Support building a culture of Safe Production<\/li><li>Work with employees to ensure a high level of accuracy and engagement on hazard identification and control<strong>&nbsp;(Critical)<\/strong><\/li><li>Engage crews and leadership to define processes that motivate working towards common goals<\/li><li>Conduct and assist in managing Hearing Conservation testing under CAOHC Certification<\/li><li>Conduct and assist in managing Industrial Hygiene testing focused primarily on noise and dust exposure.<\/li><li>Assist with MSHA regulatory training and verify compliance to standards.<\/li><li>Live the values as part of a visible daily decision-making process<\/li><li>Audit sites while focusing on conditions and behaviors that reflect our desire to be the best in the business.<\/li><li>Assist in problem-solving including incident investigations, root cause analysis, and corrective action development.<\/li><li>Learn and assist with key performance indicators, company targets, and progress reporting.<\/li><li>Assist with and lead crew \/ supervision development opportunities.<\/li><li>Assist with client specific safety needs as required.<\/li><li>Support risk assessment processes at various levels of the organization including field level risk, project-based risk, and organizational risk management.<\/li><\/ul>\n<p><strong>Culture and Communication:<\/strong><\/p>\n<ul><li>Foster excitement throughout the organization by taking safety to new heights through cutting edge ideas and tactics.<\/li><li>Assist with site milestone recognition programs.<\/li><li>Assist with site communication programs and processes to ensure timely, specific, and value-added information.<\/li><li>Partner with site and project leaders to identify areas of improvement.<\/li><li>Develop and implement processes to reduce and eliminate repeat incidents<\/li><li>Assist site leaders with quality safety toolbox talks<\/li><li>Work with crews to support proactive near miss reporting.<\/li><li>Be visible with site leadership and crews. Spend time with Operations, Maintenance, and Site<\/li><li>Supervision to build relationships and develop trust.<\/li><\/ul>\n<p><strong>Systems:<\/strong><\/p>\n<ul><li>Support safety documentation platforms including HCSS, SharePoint, Adobe, and regulatory required systems.<\/li><li>Support incident tracking processes.<\/li><li>Ensure consistent use of root cause methodology<\/li><li>Implementation and use of risk analysis tools evaluating business processes and task-based risks<\/li><\/ul>\n<p><strong>Processes:<\/strong><\/p>\n<ul><li>Assist with leading and lagging indicators across the sites.<\/li><li>Work with leaders to develop ideas and improvement opportunities<\/li><li>Participate and support new project kick off requirements as well as closing other sites \/ projects.<\/li><li>Stay current with industry trends, regulations, and best practices in safety management, and recommend updates to company policies and procedures as needed.<\/li><li>Assist in writing and updating policies \/ procedures \/ and work instructions using professional writing language.<\/li><\/ul>\n<p><strong>Time and Interactions:<\/strong><\/p>\n<ul><li>This Safety Support Specialist role is based in Ely, NV<\/li><li>This role is designed to be site based, however travel may be required.<\/li><li>The successful candidate will be self-starting, motivated, with a strong desire to be part of a team and to influence improvement.<\/li><li>Communication is also critical to keep leadership and site-based personnel in the loop of successes, challenges, and any additional support that may be required. Building credibility is key with the sites and supporting their safety needs.<\/li><\/ul>\n<p><strong>Qualifications:<\/strong><\/p>\n<ul><li>Microsoft Office proficiency<\/li><li>Must be motivated to look for site \/ crew \/ system improvement opportunities- Required<\/li><li>Proficiency in safety data and use of safety systems \u2013 Preferred<\/li><li>Ability to learn in a fast-paced environment - Required<\/li><li>Understanding of OSHA \/ MSHA regulatory requirements - Blue Card certification preferred<\/li><li>Bachelor\u2019s degree in occupational safety and health or equivalent preferred<\/li><li>3-8 years\u2019 experience in mining \/ heavy industry preferred<\/li><li>Working knowledge of safety systems and processes<\/li><li>Proficiency in written presentations and processes<\/li><li>Appropriate attention to detail required<\/li><li>The successful candidate must be passionate about their role and the success of Turner Mining Group.<\/li><\/ul>","%category%":"Other","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/ca0185072b4d-safety-support-specialist","%breezy_id%":"ca0185072b4d","%breezy_friendly_id%":"ca0185072b4d-safety-support-specialist","%breezy_created_date%":"2025-10-03T18:12:21.505Z","%breezy_updated_date%":"2025-10-13T15:20:13.977Z","%_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":2810,"infowindow_disable":false},{"source":"post","title":"Entry Level Miner","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Entry Level Miner\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Entry Level Miner &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; Reports to:&nbsp;Foreman \u2013 Turner Mining Group Job Description: The Entry Level Miner is a starting point&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/entry-level-miner-2\/\" name=\"Entry Level Miner\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Entry Level Miner &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; Reports to:&nbsp;Foreman \u2013 Turner Mining Group Job Description: The Entry Level Miner is a starting point&hellip;","address":"Ely, NV, USA","location":{"lat":"39.2533328","city":"Ely","state":"NV","country":"United States","lng":"-114.874248","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/entry-level-miner-2\/","zoom":19,"extra_fields":{"post_excerpt":"Entry Level Miner &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; Reports to:&nbsp;Foreman \u2013 Turner Mining Group Job Description: The Entry Level Miner is a starting point&hellip;","post_content":"<p><strong>Entry Level Miner<\/strong>    &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<\/p>\n<p><strong>Reports to:&nbsp;<\/strong><strong>Foreman \u2013 Turner Mining Group<\/strong><\/p>\n<p><strong>Job Description:<\/strong><\/p>\n<p>The Entry Level Miner is a starting point for both operations and maintenance within Turner Mining Group. This position will develop into a Production Miner or Fuel \/ Lube Technician role. The successful candidate must live the Turner Values and be an outward example to others. This position must demonstrate a strong commitment to \u201cSafe Production\u201d through decision making, priorities, and client relations.<\/p>\n<p><strong>Objectives and Contributions:<\/strong><\/p>\n<p>The Entry Level Miner is focused on key aspects that drive communication and safe production while maintaining a high level of efficiency, and preventative maintenance awareness requirements. The Entry Level Miner demonstrates safety ownership at a personal level and holds other crew members to the same high standard.<\/p>\n<ul><li>Work with employees to ensure a high level of accuracy and engagement on hazard identification and control<\/li><li>Engage crews and leadership to define processes that motivate working towards common goals<\/li><li>Assist with MSHA regulatory task training and verify compliance to standards<\/li><li>Live the values as part of a visible daily decision-making process<\/li><li>Involvement in risk assessment processes at various levels of the organization<\/li><li>Holds themselves and others accountable for acting like an owner (taking care of equipment, not wasting resources, using time wisely, and being accountable for conditions and behaviors)<\/li><li>Maintains a high standard of housekeeping (machine and work areas)<\/li><\/ul>\n<p><u>Culture and Communication:<\/u><\/p>\n<ul><li>Can effectively communicate in English (multi-lingual preferred)<\/li><li>Work with crews to support proactive near miss reporting<\/li><li>Leads by example (walks the talk)<\/li><\/ul>\n<p><u>Systems:<\/u><\/p>\n<ul><li>Trains to Turner standards to perform quality pre-operation machine inspections (Based on mobile equipment physical demands analysis)<\/li><li>Trains to Turner standards to accurately document 5000-23 and training checklist requirements<\/li><li>Other regulatory &amp; internal \/ external forms as required<\/li><li>Maintains a valid and insurable driving license<\/li><\/ul>\n<p><u>Travel and New Site Development:<\/u><\/p>\n<p><u>Time and Interactions:<\/u><\/p>\n<ul><li>The Entry Level Miner must be flexible on shift schedules (days and nights) to assist with training and production needs<\/li><li>The Entry Level Miner will be self-starting, motivated, with a strong desire to be part of a team and to influence improvement. Communication is also critical to keep leadership and site-based personnel in the loop of successes, challenges, and any additional support that may be required<\/li><li>Excellent time management skills<\/li><\/ul>\n<p><u>Qualifications:<\/u><\/p>\n<ul><li>Willingness and ability to adhere to OSHA \/ MSHA regulatory requirements<\/li><li>Entry Level Miners will be subject to a probationary period of six months from the date of hire<\/li><li>0-1 years\u2019 experience in mining \/ heavy industry preferred<\/li><li>Ability to obtain a working knowledge of safety systems and processes<\/li><li>Appropriate attention to detail required<\/li><li>Strong communication skills<\/li><li>Strong morals and values<\/li><li>Exemplary attendance record<\/li><li>Exemplary safety and disciplinary record<\/li><li>Willingness to be flexible on daily job duty requirements<\/li><li>Maintains a positive outspoken learning attitude<\/li><\/ul>\n<ul><li>The Entry Level Miner will become competent and highly proficient on each piece of the following equipment through on-the-job training and skills qualification<ul><li><strong>Water truck<\/strong><\/li><li><strong>Haulage Truc<\/strong><strong>k<\/strong><\/li><li><strong>OR<\/strong><\/li><li><strong>Preventative Maintenance<\/strong><\/li><li><strong>Fuel \/ Lube Truck<\/strong><\/li><\/ul><\/li><\/ul>\n<p><u>Other Duties:<\/u><\/p>\n<ul><li>In addition to the job skills above, there may be requirements for manual tasks to be completed to meet other business needs. Operators in any job duty classification may be required to participate in these additional tasks.<\/li><\/ul>\n<p><u><strong>Benefits<\/strong><\/u><br>Turner Mining Group offers a competitive salary, an excellent work culture, and career advancement opportunities. Our team provides a benefits program which includes Medical, Dental, Vision, Life, and a 401k with company match. We believe in a work-life balance and have established paid time off for major holidays.<\/p>\n<p>At Turner Mining Group, we encourage and celebrate an inclusive environment for all employees and are proud to be an equal opportunity workplace and affirmative action employer.<\/p>\n<p><\/p>","post_title":"Entry Level Miner","post_link":"https:\/\/turnerstaffing.com\/position\/entry-level-miner-2\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Entry Level","%location_country%":"United States","%location_city%":"Ely","%location_state_id%":"NV","%location_state_name%":"Nevada","%location_city_state%":"Ely, NV","%education%":"Unspecified","%department%":"Operations","%description%":"<p><strong>Entry Level Miner<\/strong>    &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<\/p>\n<p><strong>Reports to:&nbsp;<\/strong><strong>Foreman \u2013 Turner Mining Group<\/strong><\/p>\n<p><strong>Job Description:<\/strong><\/p>\n<p>The Entry Level Miner is a starting point for both operations and maintenance within Turner Mining Group. This position will develop into a Production Miner or Fuel \/ Lube Technician role. The successful candidate must live the Turner Values and be an outward example to others. This position must demonstrate a strong commitment to \u201cSafe Production\u201d through decision making, priorities, and client relations.<\/p>\n<p><strong>Objectives and Contributions:<\/strong><\/p>\n<p>The Entry Level Miner is focused on key aspects that drive communication and safe production while maintaining a high level of efficiency, and preventative maintenance awareness requirements. The Entry Level Miner demonstrates safety ownership at a personal level and holds other crew members to the same high standard.<\/p>\n<ul><li>Work with employees to ensure a high level of accuracy and engagement on hazard identification and control<\/li><li>Engage crews and leadership to define processes that motivate working towards common goals<\/li><li>Assist with MSHA regulatory task training and verify compliance to standards<\/li><li>Live the values as part of a visible daily decision-making process<\/li><li>Involvement in risk assessment processes at various levels of the organization<\/li><li>Holds themselves and others accountable for acting like an owner (taking care of equipment, not wasting resources, using time wisely, and being accountable for conditions and behaviors)<\/li><li>Maintains a high standard of housekeeping (machine and work areas)<\/li><\/ul>\n<p><u>Culture and Communication:<\/u><\/p>\n<ul><li>Can effectively communicate in English (multi-lingual preferred)<\/li><li>Work with crews to support proactive near miss reporting<\/li><li>Leads by example (walks the talk)<\/li><\/ul>\n<p><u>Systems:<\/u><\/p>\n<ul><li>Trains to Turner standards to perform quality pre-operation machine inspections (Based on mobile equipment physical demands analysis)<\/li><li>Trains to Turner standards to accurately document 5000-23 and training checklist requirements<\/li><li>Other regulatory &amp; internal \/ external forms as required<\/li><li>Maintains a valid and insurable driving license<\/li><\/ul>\n<p><u>Travel and New Site Development:<\/u><\/p>\n<p><u>Time and Interactions:<\/u><\/p>\n<ul><li>The Entry Level Miner must be flexible on shift schedules (days and nights) to assist with training and production needs<\/li><li>The Entry Level Miner will be self-starting, motivated, with a strong desire to be part of a team and to influence improvement. Communication is also critical to keep leadership and site-based personnel in the loop of successes, challenges, and any additional support that may be required<\/li><li>Excellent time management skills<\/li><\/ul>\n<p><u>Qualifications:<\/u><\/p>\n<ul><li>Willingness and ability to adhere to OSHA \/ MSHA regulatory requirements<\/li><li>Entry Level Miners will be subject to a probationary period of six months from the date of hire<\/li><li>0-1 years\u2019 experience in mining \/ heavy industry preferred<\/li><li>Ability to obtain a working knowledge of safety systems and processes<\/li><li>Appropriate attention to detail required<\/li><li>Strong communication skills<\/li><li>Strong morals and values<\/li><li>Exemplary attendance record<\/li><li>Exemplary safety and disciplinary record<\/li><li>Willingness to be flexible on daily job duty requirements<\/li><li>Maintains a positive outspoken learning attitude<\/li><\/ul>\n<ul><li>The Entry Level Miner will become competent and highly proficient on each piece of the following equipment through on-the-job training and skills qualification<ul><li><strong>Water truck<\/strong><\/li><li><strong>Haulage Truc<\/strong><strong>k<\/strong><\/li><li><strong>OR<\/strong><\/li><li><strong>Preventative Maintenance<\/strong><\/li><li><strong>Fuel \/ Lube Truck<\/strong><\/li><\/ul><\/li><\/ul>\n<p><u>Other Duties:<\/u><\/p>\n<ul><li>In addition to the job skills above, there may be requirements for manual tasks to be completed to meet other business needs. Operators in any job duty classification may be required to participate in these additional tasks.<\/li><\/ul>\n<p><u><strong>Benefits<\/strong><\/u><br>Turner Mining Group offers a competitive salary, an excellent work culture, and career advancement opportunities. Our team provides a benefits program which includes Medical, Dental, Vision, Life, and a 401k with company match. We believe in a work-life balance and have established paid time off for major holidays.<\/p>\n<p>At Turner Mining Group, we encourage and celebrate an inclusive environment for all employees and are proud to be an equal opportunity workplace and affirmative action employer.<\/p>\n<p><\/p>","%category%":"Operations","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/b0405454feeb-entry-level-miner","%breezy_id%":"b0405454feeb","%breezy_friendly_id%":"b0405454feeb-entry-level-miner","%breezy_created_date%":"2025-10-03T19:47:05.652Z","%breezy_updated_date%":"2025-10-03T19:47:48.090Z","%_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":2811,"infowindow_disable":false},{"source":"post","title":"LTE Network Field Engineer","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    LTE Network Field Engineer\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    POSITION OVERVIEW The LTE Network Field Engineer plays a critical role in supporting and maintaining the enterprise network infrastructure at&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/lte-network-field-engineer\/\" name=\"LTE Network Field Engineer\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"POSITION OVERVIEW The LTE Network Field Engineer plays a critical role in supporting and maintaining the enterprise network infrastructure at&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\/lte-network-field-engineer\/","zoom":19,"extra_fields":{"post_excerpt":"POSITION OVERVIEW The LTE Network Field Engineer plays a critical role in supporting and maintaining the enterprise network infrastructure at&hellip;","post_content":"<p><strong>POSITION OVERVIEW<\/strong><\/p>\n<p>The <strong>LTE Network Field Engineer<\/strong> plays a critical role in supporting and maintaining the enterprise network infrastructure at ASARCO, with a strong focus on LTE connectivity and field-deployed technologies. This position combines hands-on technical proficiency with strategic contribution, ensuring robust, secure, and high-performance communication systems for both IT and Operational Technology (OT) environments.<\/p>\n<p><strong>ESSENTIAL FUNCTIONS<\/strong><\/p>\n<p><strong>LTE Network Support:<\/strong><\/p>\n<p>Provide hands-on support for the Nokia LTE infrastructure, ensuring uninterrupted performance for AHS and other field automation systems.<\/p>\n<p><strong>Field Deployment &amp; Troubleshooting:<\/strong><\/p>\n<p>Perform installation, testing, and diagnostics of LTE base stations, user equipment (UE), antennas, and backhaul components in harsh mining environments.<\/p>\n<p><strong>Performance Monitoring:<\/strong><\/p>\n<p>Use network monitoring tools to track LTE performance, identify bottlenecks, and proactively resolve issues impacting availability, latency, or throughput.<\/p>\n<p><strong>Cross-Team Collaboration:<\/strong><\/p>\n<p>Work with OT, AHS operations, IT networking, and vendor teams to troubleshoot LTE-related issues and coordinate firmware or configuration changes.<\/p>\n<p><strong>Documentation:<\/strong><\/p>\n<p>Maintain current technical documentation for LTE components, coverage maps, asset inventories, and work procedures.<\/p>\n<p>.<\/p>\n<p><strong>ADDITIONAL DUTIES<\/strong><\/p>\n<p><strong>Support Projects and Upgrades:<\/strong><\/p>\n<p>Participate in LTE expansion efforts, including site surveys, RF planning, and new equipment commissioning.<\/p>\n<p><strong>Incident Response:<\/strong><\/p>\n<p>Serve as the front-line responder for Severity 1 and 2 incidents related to LTE and network infrastructure.<\/p>\n<p><strong>After-Hours Availability:<\/strong><\/p>\n<p>Be available for critical after-hours tasks to minimize operational disruptions during upgrades or maintenance.<\/p>\n<p><strong>Network Governance:<\/strong><\/p>\n<p>Review and approve LTE-related change control requests, ensuring alignment with best practices and security standards.<\/p>\n<p><strong>RESPONSIBILITIES<\/strong><\/p>\n<p>The LTE network engineer is responsible for:<\/p>\n<ul>\n <li>Ensure      secure and stable LTE-based communication for AHS trucks, field devices,      and industrial sensors.<\/li>\n <li>Design      and implement enhancements in LTE topology, IP routing, and wireless      coverage for operational continuity.<\/li>\n <li>Maintain      strict adherence to the Purdue Model principles and network zone      segmentation, while aligning with NIST cybersecurity guidelines and IEC      62443 standards for industrial control system security.<\/li>\n <li>Assist      with backhaul integration between LTE and core IT\/OT infrastructure.<\/li>\n <li>Contribute      to audits, root cause analyses, and continuous improvement of LTE-related      performance metrics.<\/li>\n<\/ul>\n<p><strong>Technical Expertise<\/strong><\/p>\n<p><strong>LTE and Networking Expertise<\/strong><\/p>\n<ul>\n <li>Deep      understanding of <strong>LTE architecture<\/strong> including eNodeBs,      EPC\/core, UE configuration, and QoS principles.<\/li>\n <li>Experience      working with <strong>Nokia LTE technologies<\/strong>, configuration tools, and      radio planning practices.<\/li>\n <li>Familiarity      with:<\/li>\n <ul>\n  <li><strong>IP       routing<\/strong> (OSPF, BGP), <strong>static routes<\/strong>, <strong>VPNs<\/strong><\/li>\n  <li>Firewalls       (Fortinet, Palo Alto, Cisco ASA)<\/li>\n  <li>Wireless       standards (802.11) and <strong>RF propagation analysis tools<\/strong> (EkaHau,       iBwave, or similar)<\/li>\n  <li><strong>Industrial       networking protocols<\/strong> (Modbus, Profinet)<\/li>\n <\/ul>\n <li>Understanding      of <strong>licensed and unlicensed wireless bands<\/strong> and related use      cases (e.g., CBRS, ISM).<\/li>\n<\/ul>\n<ul>\n <li>Awareness      of <strong>federal spectrum management regulations<\/strong> (e.g., FCC      Part 90\/96 in the U.S. or international equivalents).<\/li>\n<\/ul>\n<ul>\n <li>Experience      configuring, deploying, and troubleshooting point-to-point and      point-to-multipoint wireless links in outdoor or industrial environments.<\/li>\n<\/ul>\n<p><strong>Tools and Technical Proficiency<\/strong><\/p>\n<ul>\n <li>Monitoring      tools (Wireshark, SolarWinds, OPManager)<\/li>\n <li>Scripting      (PowerShell, Python), network diagramming (Lucidchart, MS Visio)<\/li>\n <li>Understanding      of the OSI model, CPwE framework, and Purdue Model for industrial network      segmentation, along with familiarity with NIST standards and IEC 62443 for      securing OT environments.<\/li>\n <li>Strong      proficiency in troubleshooting Layer 2 and Layer 3 network issues, with a      solid understanding of wireless network operations and associated hardware      components.<\/li>\n <li>Responsible      for executing, supporting, and enforcing the Company's Environmental,      Health and Safety program as required by OIS policy, directives, and      principles.<\/li>\n<\/ul>\n<p><strong>Desirable Skills<\/strong><\/p>\n<ul>\n <li>Experience      in <strong>mining or industrial environments<\/strong><\/li>\n <li>Ability      to interface with <strong>OEM vendors<\/strong>, <strong>LTE specialists<\/strong>,      and <strong>automation system integrators<\/strong><\/li>\n <li>Strong      field troubleshooting and hands-on problem-solving abilities<\/li>\n<\/ul>\n<p><strong>Education and Experience<\/strong><\/p>\n<ul>\n <li><strong>Required:<\/strong><\/li>\n <ul>\n  <li>High       school diploma or GED<\/li>\n  <li>5+       years\u2019 experience in relevant network infrastructure roles<\/li>\n  <li>Valid       driver\u2019s license and ability to work in field environments<\/li>\n  <li> English       language fluency.<\/li>\n <\/ul>\n<\/ul>\n<p>o   At least CEFR B2 - Upper Intermediate: Can understand the main ideas of complex text on both concrete and abstract topics, including technical discussions in their field of specialization.<\/p>\n<ul>\n <li><strong>Preferred:<\/strong><\/li>\n <ul>\n  <li>Bachelor's       degree in Computer Science, Information Technology, or related field<\/li>\n  <li>Certifications       in Cisco, Nokia, or other wireless\/networking disciplines<\/li>\n  <li>Experience       supporting LTE for <strong>Autonomous Haulage Systems<\/strong> or       comparable applications<\/li>\n <\/ul>\n<\/ul>","post_title":"LTE Network Field Engineer","post_link":"https:\/\/turnerstaffing.com\/position\/lte-network-field-engineer\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Mid Level","%location_country%":"United States","%location_city%":"Kearny","%location_state_id%":"AZ","%location_state_name%":"Arizona","%location_city_state%":"Kearny, AZ","%education%":"Bachelor's Degree","%department%":"Engineering","%description%":"<p><strong>POSITION OVERVIEW<\/strong><\/p>\n<p>The <strong>LTE Network Field Engineer<\/strong> plays a critical role in supporting and maintaining the enterprise network infrastructure at ASARCO, with a strong focus on LTE connectivity and field-deployed technologies. This position combines hands-on technical proficiency with strategic contribution, ensuring robust, secure, and high-performance communication systems for both IT and Operational Technology (OT) environments.<\/p>\n<p><strong>ESSENTIAL FUNCTIONS<\/strong><\/p>\n<p><strong>LTE Network Support:<\/strong><\/p>\n<p>Provide hands-on support for the Nokia LTE infrastructure, ensuring uninterrupted performance for AHS and other field automation systems.<\/p>\n<p><strong>Field Deployment &amp; Troubleshooting:<\/strong><\/p>\n<p>Perform installation, testing, and diagnostics of LTE base stations, user equipment (UE), antennas, and backhaul components in harsh mining environments.<\/p>\n<p><strong>Performance Monitoring:<\/strong><\/p>\n<p>Use network monitoring tools to track LTE performance, identify bottlenecks, and proactively resolve issues impacting availability, latency, or throughput.<\/p>\n<p><strong>Cross-Team Collaboration:<\/strong><\/p>\n<p>Work with OT, AHS operations, IT networking, and vendor teams to troubleshoot LTE-related issues and coordinate firmware or configuration changes.<\/p>\n<p><strong>Documentation:<\/strong><\/p>\n<p>Maintain current technical documentation for LTE components, coverage maps, asset inventories, and work procedures.<\/p>\n<p>.<\/p>\n<p><strong>ADDITIONAL DUTIES<\/strong><\/p>\n<p><strong>Support Projects and Upgrades:<\/strong><\/p>\n<p>Participate in LTE expansion efforts, including site surveys, RF planning, and new equipment commissioning.<\/p>\n<p><strong>Incident Response:<\/strong><\/p>\n<p>Serve as the front-line responder for Severity 1 and 2 incidents related to LTE and network infrastructure.<\/p>\n<p><strong>After-Hours Availability:<\/strong><\/p>\n<p>Be available for critical after-hours tasks to minimize operational disruptions during upgrades or maintenance.<\/p>\n<p><strong>Network Governance:<\/strong><\/p>\n<p>Review and approve LTE-related change control requests, ensuring alignment with best practices and security standards.<\/p>\n<p><strong>RESPONSIBILITIES<\/strong><\/p>\n<p>The LTE network engineer is responsible for:<\/p>\n<ul>\n <li>Ensure      secure and stable LTE-based communication for AHS trucks, field devices,      and industrial sensors.<\/li>\n <li>Design      and implement enhancements in LTE topology, IP routing, and wireless      coverage for operational continuity.<\/li>\n <li>Maintain      strict adherence to the Purdue Model principles and network zone      segmentation, while aligning with NIST cybersecurity guidelines and IEC      62443 standards for industrial control system security.<\/li>\n <li>Assist      with backhaul integration between LTE and core IT\/OT infrastructure.<\/li>\n <li>Contribute      to audits, root cause analyses, and continuous improvement of LTE-related      performance metrics.<\/li>\n<\/ul>\n<p><strong>Technical Expertise<\/strong><\/p>\n<p><strong>LTE and Networking Expertise<\/strong><\/p>\n<ul>\n <li>Deep      understanding of <strong>LTE architecture<\/strong> including eNodeBs,      EPC\/core, UE configuration, and QoS principles.<\/li>\n <li>Experience      working with <strong>Nokia LTE technologies<\/strong>, configuration tools, and      radio planning practices.<\/li>\n <li>Familiarity      with:<\/li>\n <ul>\n  <li><strong>IP       routing<\/strong> (OSPF, BGP), <strong>static routes<\/strong>, <strong>VPNs<\/strong><\/li>\n  <li>Firewalls       (Fortinet, Palo Alto, Cisco ASA)<\/li>\n  <li>Wireless       standards (802.11) and <strong>RF propagation analysis tools<\/strong> (EkaHau,       iBwave, or similar)<\/li>\n  <li><strong>Industrial       networking protocols<\/strong> (Modbus, Profinet)<\/li>\n <\/ul>\n <li>Understanding      of <strong>licensed and unlicensed wireless bands<\/strong> and related use      cases (e.g., CBRS, ISM).<\/li>\n<\/ul>\n<ul>\n <li>Awareness      of <strong>federal spectrum management regulations<\/strong> (e.g., FCC      Part 90\/96 in the U.S. or international equivalents).<\/li>\n<\/ul>\n<ul>\n <li>Experience      configuring, deploying, and troubleshooting point-to-point and      point-to-multipoint wireless links in outdoor or industrial environments.<\/li>\n<\/ul>\n<p><strong>Tools and Technical Proficiency<\/strong><\/p>\n<ul>\n <li>Monitoring      tools (Wireshark, SolarWinds, OPManager)<\/li>\n <li>Scripting      (PowerShell, Python), network diagramming (Lucidchart, MS Visio)<\/li>\n <li>Understanding      of the OSI model, CPwE framework, and Purdue Model for industrial network      segmentation, along with familiarity with NIST standards and IEC 62443 for      securing OT environments.<\/li>\n <li>Strong      proficiency in troubleshooting Layer 2 and Layer 3 network issues, with a      solid understanding of wireless network operations and associated hardware      components.<\/li>\n <li>Responsible      for executing, supporting, and enforcing the Company's Environmental,      Health and Safety program as required by OIS policy, directives, and      principles.<\/li>\n<\/ul>\n<p><strong>Desirable Skills<\/strong><\/p>\n<ul>\n <li>Experience      in <strong>mining or industrial environments<\/strong><\/li>\n <li>Ability      to interface with <strong>OEM vendors<\/strong>, <strong>LTE specialists<\/strong>,      and <strong>automation system integrators<\/strong><\/li>\n <li>Strong      field troubleshooting and hands-on problem-solving abilities<\/li>\n<\/ul>\n<p><strong>Education and Experience<\/strong><\/p>\n<ul>\n <li><strong>Required:<\/strong><\/li>\n <ul>\n  <li>High       school diploma or GED<\/li>\n  <li>5+       years\u2019 experience in relevant network infrastructure roles<\/li>\n  <li>Valid       driver\u2019s license and ability to work in field environments<\/li>\n  <li> English       language fluency.<\/li>\n <\/ul>\n<\/ul>\n<p>o   At least CEFR B2 - Upper Intermediate: Can understand the main ideas of complex text on both concrete and abstract topics, including technical discussions in their field of specialization.<\/p>\n<ul>\n <li><strong>Preferred:<\/strong><\/li>\n <ul>\n  <li>Bachelor's       degree in Computer Science, Information Technology, or related field<\/li>\n  <li>Certifications       in Cisco, Nokia, or other wireless\/networking disciplines<\/li>\n  <li>Experience       supporting LTE for <strong>Autonomous Haulage Systems<\/strong> or       comparable applications<\/li>\n <\/ul>\n<\/ul>","%category%":"Other","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/a8d3773693ae-lte-network-field-engineer","%breezy_id%":"a8d3773693ae","%breezy_friendly_id%":"a8d3773693ae-lte-network-field-engineer","%breezy_created_date%":"2025-09-30T13:37:01.928Z","%breezy_updated_date%":"2025-09-30T13:37:57.777Z","%_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":2800,"infowindow_disable":false},{"source":"post","title":"General Laborer","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    General Laborer\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Turner Mining Group \u2013 Laborer Do you love mining? Do you think differently? Are you ready to define the future&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/general-laborer\/\" name=\"General Laborer\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Turner Mining Group \u2013 Laborer Do you love mining? Do you think differently? Are you ready to define the future&hellip;","address":"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\/general-laborer\/","zoom":19,"extra_fields":{"post_excerpt":"Turner Mining Group \u2013 Laborer Do you love mining? Do you think differently? Are you ready to define the future&hellip;","post_content":"<p><strong><u>Turner Mining Group \u2013 Laborer<\/u><\/strong><\/p>\n<p>Do you love mining? Do you think differently? Are you ready to define the future of this industry?<\/p>\n<p>We\u2019ve been waiting for you! Turner Mining Group is committed to changing the way mining companies do business. We develop our people. We partner with our clients. We believe in win, win, win.<\/p>\n<p>We are looking for a laborer for our fast-growing, forward thinking mining services company headquartered in Bloomington, Indiana with our Operations team headquartered in Salt Lake City, Utah.<\/p>\n<p>Turner Mining Group is seeking an energetic mining professionals who can leverage their mining knowledge to expand upon our fast-growing business, creating best practices for equipment operations to ensure profitable operations.<\/p>\n<p><strong>You<\/strong><\/p>\n<p>You want to work for a services company that is rapidly changing the way the largest materials producers do business. You are motivated by solving problems and partnering with our clients and suppliers. You want to work with great people and enjoy being a part of a strong team. You are a safety oriented, hard working individual who is not afraid to jump into every detail. You want to be in a place where continuous learning and growth is the norm. You are adaptable and able to juggle multiple initiatives concurrently.<\/p>\n<p><strong>Responsibilities:<\/strong><\/p>\n<ul><li>Laborer duties include directional flagging of heavy and light duty traffic, stormwater BMP installation, demo, install and repair fencing and assisting in site survey and staking.<\/li><li>Duties include driving a truck, dumping loads, performing all pre-shift inspections, some basic maintenance and upkeep, and working with teammates on crew to maximize production while always maintaining our safety rules and regulations.<\/li><li>May drive special purpose vehicles, including end dump trucks, center dump truck units and water trucks<\/li><\/ul>\n<p><strong>Requirements:<\/strong><\/p>\n<ul><li>Safety oriented, awareness of everyone and everything that is around you<\/li><li>Strong work ethic<\/li><li>Willingness to learn<\/li><li>Ability to be flexible and to adapt<\/li><li>Experience with heavy equipment<\/li><li>Preferred to have MSHA training<\/li><\/ul>\n<p><strong>Benefits:<\/strong><\/p>\n<p>Turner Mining Group offers a competitive salary, an excellent work culture, career advancement opportunities. Our team offers a benefits program which includes Medical, Dental, Vision, Life, and a 401k with company match.<\/p>\n<p>At Turner Mining Group, we encourage and celebrate an inclusive environment for all employees and are proud to be an equal opportunity workplace and affirmative action employer.<\/p>","post_title":"General Laborer","post_link":"https:\/\/turnerstaffing.com\/position\/general-laborer\/","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%":"Operations","%description%":"<p><strong><u>Turner Mining Group \u2013 Laborer<\/u><\/strong><\/p>\n<p>Do you love mining? Do you think differently? Are you ready to define the future of this industry?<\/p>\n<p>We\u2019ve been waiting for you! Turner Mining Group is committed to changing the way mining companies do business. We develop our people. We partner with our clients. We believe in win, win, win.<\/p>\n<p>We are looking for a laborer for our fast-growing, forward thinking mining services company headquartered in Bloomington, Indiana with our Operations team headquartered in Salt Lake City, Utah.<\/p>\n<p>Turner Mining Group is seeking an energetic mining professionals who can leverage their mining knowledge to expand upon our fast-growing business, creating best practices for equipment operations to ensure profitable operations.<\/p>\n<p><strong>You<\/strong><\/p>\n<p>You want to work for a services company that is rapidly changing the way the largest materials producers do business. You are motivated by solving problems and partnering with our clients and suppliers. You want to work with great people and enjoy being a part of a strong team. You are a safety oriented, hard working individual who is not afraid to jump into every detail. You want to be in a place where continuous learning and growth is the norm. You are adaptable and able to juggle multiple initiatives concurrently.<\/p>\n<p><strong>Responsibilities:<\/strong><\/p>\n<ul><li>Laborer duties include directional flagging of heavy and light duty traffic, stormwater BMP installation, demo, install and repair fencing and assisting in site survey and staking.<\/li><li>Duties include driving a truck, dumping loads, performing all pre-shift inspections, some basic maintenance and upkeep, and working with teammates on crew to maximize production while always maintaining our safety rules and regulations.<\/li><li>May drive special purpose vehicles, including end dump trucks, center dump truck units and water trucks<\/li><\/ul>\n<p><strong>Requirements:<\/strong><\/p>\n<ul><li>Safety oriented, awareness of everyone and everything that is around you<\/li><li>Strong work ethic<\/li><li>Willingness to learn<\/li><li>Ability to be flexible and to adapt<\/li><li>Experience with heavy equipment<\/li><li>Preferred to have MSHA training<\/li><\/ul>\n<p><strong>Benefits:<\/strong><\/p>\n<p>Turner Mining Group offers a competitive salary, an excellent work culture, career advancement opportunities. Our team offers a benefits program which includes Medical, Dental, Vision, Life, and a 401k with company match.<\/p>\n<p>At Turner Mining Group, we encourage and celebrate an inclusive environment for all employees and are proud to be an equal opportunity workplace and affirmative action employer.<\/p>","%category%":"Operations","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/bd975992bae4-general-laborer","%breezy_id%":"bd975992bae4","%breezy_friendly_id%":"bd975992bae4-general-laborer","%breezy_created_date%":"2025-09-30T14:43:30.538Z","%breezy_updated_date%":"2025-09-30T14:44:26.724Z","%_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":2801,"infowindow_disable":false},{"source":"post","title":"Pipe Supervisor","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Pipe Supervisor\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Pipe Supervisor Summary Oversee and coordinate all pipe and utility installation activities, ensuring safe, high-quality, and cost-effective work. Supervise crews,&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/pipe-supervisor\/\" name=\"Pipe Supervisor\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Pipe Supervisor Summary Oversee and coordinate all pipe and utility installation activities, ensuring safe, high-quality, and cost-effective work. Supervise crews,&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\/pipe-supervisor\/","zoom":19,"extra_fields":{"post_excerpt":"Pipe Supervisor Summary Oversee and coordinate all pipe and utility installation activities, ensuring safe, high-quality, and cost-effective work. Supervise crews,&hellip;","post_content":"<h1>Pipe Supervisor<\/h1>\n<p>Summary<\/p>\n<p>Oversee and coordinate all pipe and utility installation activities, ensuring safe, high-quality, and cost-effective work. Supervise crews, equipment, and subcontractors while maintaining customer satisfaction and profitability.<\/p>\n<h3>Key Responsibilities<\/h3>\n<ul>\n<li>\n<p><strong>Crew Management<\/strong>: Train, supervise, and support pipe crew; enforce company policies; ensure effective communication with management.<\/p>\n<\/li>\n<li>\n<p><strong>Safety<\/strong>: Promote and enforce safety policies; provide orientations; investigate\/report incidents; maintain first aid\/CPR readiness.<\/p>\n<\/li>\n<li>\n<p><strong>Technical<\/strong>: Review blueprints, contracts, and specs; set and compute grades; calculate quantities; apply soils knowledge; ensure efficient sequencing of work.<\/p>\n<\/li>\n<li>\n<p><strong>Project Execution<\/strong>: Plan and schedule activities; monitor costs, productivity, and budgets; avoid rework; track and report progress.<\/p>\n<\/li>\n<li>\n<p><strong>Equipment Oversight<\/strong>: Supervise equipment use, maintenance, and security.<\/p>\n<\/li>\n<li>\n<p><strong>Customer &amp; Public Relations<\/strong>: Maintain positive relationships with clients, municipalities, and neighbors; resolve issues professionally.<\/p>\n<\/li>\n<li>\n<p><strong>Administration<\/strong>: Prepare reports, maintain documentation, and attend meetings.<\/p>\n<\/li>\n<\/ul>\n<h3>Requirements<\/h3>\n<ul>\n<li>\n<p><strong>Education\/Experience<\/strong>:<\/p>\n<ul>\n<li>\n<p>High school diploma or GED.<\/p>\n<\/li>\n<li>\n<p>5+ years pipe\/utility installation experience.<\/p>\n<\/li>\n<li>\n<p>2+ years supervisory experience.<\/p>\n<\/li>\n<\/ul>\n<\/li>\n<li>\n<p><strong>Skills<\/strong>:<\/p>\n<ul>\n<li>\n<p>Read\/interpret blueprints and contracts.<\/p>\n<\/li>\n<li>\n<p>Strong math skills (grades, volumes, tonnage).<\/p>\n<\/li>\n<li>\n<p>Problem-solving and decision-making.<\/p>\n<\/li>\n<li>\n<p>Strong communication and leadership abilities.<\/p>\n<\/li>\n<\/ul>\n<\/li>\n<li>\n<p><strong>Licenses<\/strong>: Valid driver\u2019s license.<\/p>\n<\/li>\n<\/ul>\n<h3>Physical Demands &amp; Environment<\/h3>\n<ul>\n<li>\n<p>Physically fit; able to lift 50+ lbs, stand for long periods, and work in rough terrain.<\/p>\n<\/li>\n<li>\n<p>Exposure to outdoor elements (heat, cold, rain, snow, dust, noise).<\/p><\/li><\/ul>","post_title":"Pipe Supervisor","post_link":"https:\/\/turnerstaffing.com\/position\/pipe-supervisor\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Mid Level","%location_country%":"United States","%location_city%":"Bowmansville","%location_state_id%":"PA","%location_state_name%":"Pennsylvania","%location_city_state%":"Bowmansville, PA","%education%":"High School or Equivalent","%department%":"","%description%":"<h1>Pipe Supervisor<\/h1>\n<p>Summary<\/p>\n<p>Oversee and coordinate all pipe and utility installation activities, ensuring safe, high-quality, and cost-effective work. Supervise crews, equipment, and subcontractors while maintaining customer satisfaction and profitability.<\/p>\n<h3>Key Responsibilities<\/h3>\n<ul>\n<li>\n<p><strong>Crew Management<\/strong>: Train, supervise, and support pipe crew; enforce company policies; ensure effective communication with management.<\/p>\n<\/li>\n<li>\n<p><strong>Safety<\/strong>: Promote and enforce safety policies; provide orientations; investigate\/report incidents; maintain first aid\/CPR readiness.<\/p>\n<\/li>\n<li>\n<p><strong>Technical<\/strong>: Review blueprints, contracts, and specs; set and compute grades; calculate quantities; apply soils knowledge; ensure efficient sequencing of work.<\/p>\n<\/li>\n<li>\n<p><strong>Project Execution<\/strong>: Plan and schedule activities; monitor costs, productivity, and budgets; avoid rework; track and report progress.<\/p>\n<\/li>\n<li>\n<p><strong>Equipment Oversight<\/strong>: Supervise equipment use, maintenance, and security.<\/p>\n<\/li>\n<li>\n<p><strong>Customer &amp; Public Relations<\/strong>: Maintain positive relationships with clients, municipalities, and neighbors; resolve issues professionally.<\/p>\n<\/li>\n<li>\n<p><strong>Administration<\/strong>: Prepare reports, maintain documentation, and attend meetings.<\/p>\n<\/li>\n<\/ul>\n<h3>Requirements<\/h3>\n<ul>\n<li>\n<p><strong>Education\/Experience<\/strong>:<\/p>\n<ul>\n<li>\n<p>High school diploma or GED.<\/p>\n<\/li>\n<li>\n<p>5+ years pipe\/utility installation experience.<\/p>\n<\/li>\n<li>\n<p>2+ years supervisory experience.<\/p>\n<\/li>\n<\/ul>\n<\/li>\n<li>\n<p><strong>Skills<\/strong>:<\/p>\n<ul>\n<li>\n<p>Read\/interpret blueprints and contracts.<\/p>\n<\/li>\n<li>\n<p>Strong math skills (grades, volumes, tonnage).<\/p>\n<\/li>\n<li>\n<p>Problem-solving and decision-making.<\/p>\n<\/li>\n<li>\n<p>Strong communication and leadership abilities.<\/p>\n<\/li>\n<\/ul>\n<\/li>\n<li>\n<p><strong>Licenses<\/strong>: Valid driver\u2019s license.<\/p>\n<\/li>\n<\/ul>\n<h3>Physical Demands &amp; Environment<\/h3>\n<ul>\n<li>\n<p>Physically fit; able to lift 50+ lbs, stand for long periods, and work in rough terrain.<\/p>\n<\/li>\n<li>\n<p>Exposure to outdoor elements (heat, cold, rain, snow, dust, noise).<\/p><\/li><\/ul>","%category%":"Operations","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/bde01bde61d8-pipe-supervisor","%breezy_id%":"bde01bde61d8","%breezy_friendly_id%":"bde01bde61d8-pipe-supervisor","%breezy_created_date%":"2025-09-26T20:48:19.906Z","%breezy_updated_date%":"2025-09-26T20:52:36.113Z","%_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":2787,"infowindow_disable":false},{"source":"post","title":"Paving Foreman","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Paving Foreman\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    The Paving Foreman will play a pivotal role in overseeing and managing all aspects of paving operations on construction sites.&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/paving-foreman-2\/\" name=\"Paving Foreman\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"The Paving Foreman will play a pivotal role in overseeing and managing all aspects of paving operations on construction sites.&hellip;","address":"Chesapeake, VA, USA","location":{"lat":"36.7682088","city":"Chesapeake","state":"VA","country":"United States","lng":"-76.2874927","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/paving-foreman-2\/","zoom":19,"extra_fields":{"post_excerpt":"The Paving Foreman will play a pivotal role in overseeing and managing all aspects of paving operations on construction sites.&hellip;","post_content":"<p>The Paving Foreman will play a pivotal role in overseeing and managing all aspects of paving operations on construction sites. The ideal candidate will have a strong background in paving techniques, materials, equipment operation, team leadership, and safety protocols. The Paving Foreman will collaborate closely with project managers, engineers, and field staff to ensure the successful completion of paving projects within established timelines and quality standards. They will be responsible for supervising and directing assigned crew members in preparing, executing, and finishing asphalt paving projects.<\/p>\n<p><\/p>\n<p>This role is fast paced and requires someone who can take ownership of their work, make informed decisions, and coordinate with and direct the activities of all job site crews, subcontractors, and material and equipment providers. Additionally, the candidate must effectively interface with clients, inspectors, regulatory representatives, and other key individuals within the organization.<\/p>\n<p><\/p>\n<p><em>Responsibilities:&nbsp;<\/em><\/p>\n<ul><li>Demonstrates technical proficiency in multiple aspects of asphalt paving.<\/li><li>Supervises hourly crewmembers and plans\/schedules manpower and equipment as needed.<\/li><li>Manages deliveries from suppliers and subcontractors to ensure safety, profit, scheduling compliance and customer satisfaction.<\/li><li>Follows our client's Safety Program including preplanning to identify conditions and exposures, proper safety and personal protective equipment and accident investigation and reporting.<\/li><li>Coordinates and collaborates with other Foremen, Superintendents, and the customer to implement successful project plans.<\/li><li>Provides on the job training to crewmembers for assigned tasks.<\/li><li>Communicates performance expectations for productivity, quality, and safety to crews and ensures progress towards expectations.<\/li><li>Administers timely and accurate documentation for project-related activities including change orders, time and materials, purchase orders, daily job control reports and receiving slips\/invoices.<\/li><\/ul>\n<h2>Qualifications<\/h2>\n<ul><li>High school diploma or equivalent (GED) required (continuing education in construction highly desirable).<\/li><li>Minimum 2 years of heavy highway, asphalt paving&nbsp;experience.<\/li><li>OSHA 10 hour required.<\/li><li>Valid driver\u2019s license required<\/li><\/ul>","post_title":"Paving Foreman","post_link":"https:\/\/turnerstaffing.com\/position\/paving-foreman-2\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Mid Level","%location_country%":"United States","%location_city%":"Chesapeake","%location_state_id%":"VA","%location_state_name%":"Virginia","%location_city_state%":"Chesapeake, VA","%education%":"High School or Equivalent","%department%":"","%description%":"<p>The Paving Foreman will play a pivotal role in overseeing and managing all aspects of paving operations on construction sites. The ideal candidate will have a strong background in paving techniques, materials, equipment operation, team leadership, and safety protocols. The Paving Foreman will collaborate closely with project managers, engineers, and field staff to ensure the successful completion of paving projects within established timelines and quality standards. They will be responsible for supervising and directing assigned crew members in preparing, executing, and finishing asphalt paving projects.<\/p>\n<p><\/p>\n<p>This role is fast paced and requires someone who can take ownership of their work, make informed decisions, and coordinate with and direct the activities of all job site crews, subcontractors, and material and equipment providers. Additionally, the candidate must effectively interface with clients, inspectors, regulatory representatives, and other key individuals within the organization.<\/p>\n<p><\/p>\n<p><em>Responsibilities:&nbsp;<\/em><\/p>\n<ul><li>Demonstrates technical proficiency in multiple aspects of asphalt paving.<\/li><li>Supervises hourly crewmembers and plans\/schedules manpower and equipment as needed.<\/li><li>Manages deliveries from suppliers and subcontractors to ensure safety, profit, scheduling compliance and customer satisfaction.<\/li><li>Follows our client's Safety Program including preplanning to identify conditions and exposures, proper safety and personal protective equipment and accident investigation and reporting.<\/li><li>Coordinates and collaborates with other Foremen, Superintendents, and the customer to implement successful project plans.<\/li><li>Provides on the job training to crewmembers for assigned tasks.<\/li><li>Communicates performance expectations for productivity, quality, and safety to crews and ensures progress towards expectations.<\/li><li>Administers timely and accurate documentation for project-related activities including change orders, time and materials, purchase orders, daily job control reports and receiving slips\/invoices.<\/li><\/ul>\n<h2>Qualifications<\/h2>\n<ul><li>High school diploma or equivalent (GED) required (continuing education in construction highly desirable).<\/li><li>Minimum 2 years of heavy highway, asphalt paving&nbsp;experience.<\/li><li>OSHA 10 hour required.<\/li><li>Valid driver\u2019s license required<\/li><\/ul>","%category%":"Management","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/17326c5917ec-paving-foreman","%breezy_id%":"17326c5917ec","%breezy_friendly_id%":"17326c5917ec-paving-foreman","%breezy_created_date%":"2025-09-25T13:39:01.061Z","%breezy_updated_date%":"2025-09-25T13:46:31.743Z","%_wpgmp_location_city%":"Chesapeake","%_wpgmp_location_state%":"VA","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Chesapeake, VA, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"36.7682088","%_wpgmp_metabox_longitude%":"-76.2874927","%rank_math_internal_links_processed%":"1"}},"id":2784,"infowindow_disable":false},{"source":"post","title":"Pipe Layer","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Pipe Layer\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Are you hungry \/ humble \/ smart? Do you think differently? Are you ready to find an opportunity that offers&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/pipe-layer\/\" name=\"Pipe Layer\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Are you hungry \/ humble \/ smart? Do you think differently? Are you ready to find an opportunity that offers&hellip;","address":"Lancaster, PA, USA","location":{"lat":"40.0403279","city":"Lancaster","state":"PA","country":"United States","lng":"-76.3041833","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/pipe-layer\/","zoom":19,"extra_fields":{"post_excerpt":"Are you hungry \/ humble \/ smart? Do you think differently? Are you ready to find an opportunity that offers&hellip;","post_content":"<p>Are you hungry \/ humble \/ smart? Do you think differently? Are you ready to find an opportunity that offers REAL growth?<\/p>\n<p>We\u2019ve been waiting for you!<br><\/p>\n<p><strong>You<\/strong><\/p>\n<p>You want to work for a services company that is rapidly changing the way the way pipe work is conducted. You are motivated by solving problems and partnering with our clients and suppliers. You want to work with great people and enjoy being a part of a strong team. You are a safety oriented, hard working individual who is not afraid to jump into every detail. You want to be in a place where continuous learning and growth is the norm. You are adaptable and able to juggle multiple initiatives concurrently.<\/p>\n<p><strong>Responsibilities:<\/strong><\/p>\n<ul><li>Laborer duties include pipe rehabilitation, stormwater BMP installation, demo, install and repair fencing and assisting in site survey and staking.<\/li><li>Duties include driving a truck, dumping loads, performing all pre-shift inspections, some basic maintenance and upkeep, and working with teammates on crew to maximize production while always maintaining our safety rules and regulations.<\/li><li>May drive special purpose vehicles, including end dump trucks, center dump truck units and water trucks<\/li><li>Willingness to learn operating equipment<\/li><li>Team Player with GREAT attitude!<\/li><\/ul>\n<p><strong>Requirements:<\/strong><\/p>\n<ul><li>Driver's License<\/li><li>Safety oriented, awareness of everyone and everything that is around you<\/li><li>Knowledge of DOT Regulations<\/li><li>Experience in heavy highway utility work&nbsp;<\/li><li>Strong work ethic<\/li><li>Willingness to learn<\/li><li>Ability to be flexible and to adapt<\/li><li>Experience with heavy equipment<\/li><\/ul>","post_title":"Pipe Layer","post_link":"https:\/\/turnerstaffing.com\/position\/pipe-layer\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Associate","%location_country%":"United States","%location_city%":"Lancaster","%location_state_id%":"PA","%location_state_name%":"Pennsylvania","%location_city_state%":"Lancaster, PA","%education%":"Unspecified","%department%":"","%description%":"<p>Are you hungry \/ humble \/ smart? Do you think differently? Are you ready to find an opportunity that offers REAL growth?<\/p>\n<p>We\u2019ve been waiting for you!<br><\/p>\n<p><strong>You<\/strong><\/p>\n<p>You want to work for a services company that is rapidly changing the way the way pipe work is conducted. You are motivated by solving problems and partnering with our clients and suppliers. You want to work with great people and enjoy being a part of a strong team. You are a safety oriented, hard working individual who is not afraid to jump into every detail. You want to be in a place where continuous learning and growth is the norm. You are adaptable and able to juggle multiple initiatives concurrently.<\/p>\n<p><strong>Responsibilities:<\/strong><\/p>\n<ul><li>Laborer duties include pipe rehabilitation, stormwater BMP installation, demo, install and repair fencing and assisting in site survey and staking.<\/li><li>Duties include driving a truck, dumping loads, performing all pre-shift inspections, some basic maintenance and upkeep, and working with teammates on crew to maximize production while always maintaining our safety rules and regulations.<\/li><li>May drive special purpose vehicles, including end dump trucks, center dump truck units and water trucks<\/li><li>Willingness to learn operating equipment<\/li><li>Team Player with GREAT attitude!<\/li><\/ul>\n<p><strong>Requirements:<\/strong><\/p>\n<ul><li>Driver's License<\/li><li>Safety oriented, awareness of everyone and everything that is around you<\/li><li>Knowledge of DOT Regulations<\/li><li>Experience in heavy highway utility work&nbsp;<\/li><li>Strong work ethic<\/li><li>Willingness to learn<\/li><li>Ability to be flexible and to adapt<\/li><li>Experience with heavy equipment<\/li><\/ul>","%category%":"Operations","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/fb9406690f01-pipe-layer","%breezy_id%":"fb9406690f01","%breezy_friendly_id%":"fb9406690f01-pipe-layer","%breezy_created_date%":"2025-04-07T16:26:31.431Z","%breezy_updated_date%":"2025-10-24T20:41:22.062Z","%_wpgmp_location_city%":"Lancaster","%_wpgmp_location_state%":"PA","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Lancaster, PA, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"40.0403279","%_wpgmp_metabox_longitude%":"-76.3041833","%rank_math_internal_links_processed%":"1"}},"id":2783,"infowindow_disable":false},{"source":"post","title":"Marketing Manager","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Marketing Manager\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Marketing Manager Overview Do you believe marketing should drive real results? Do you think differently about partnership-driven growth? Are you&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/marketing-manager\/\" name=\"Marketing Manager\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Marketing Manager Overview Do you believe marketing should drive real results? Do you think differently about partnership-driven growth? Are 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\/marketing-manager\/","zoom":19,"extra_fields":{"post_excerpt":"Marketing Manager Overview Do you believe marketing should drive real results? Do you think differently about partnership-driven growth? Are you&hellip;","post_content":"<p><strong>Marketing Manager<\/strong><\/p>\n<p><strong>Overview<\/strong><\/p>\n<p><strong>Do you believe marketing should drive real results? Do you think differently about partnership-driven growth? Are you ready to help redefine how the mining industry does business?<\/strong><\/p>\n<p><strong>We've been waiting for you!<\/strong> Turner Mining Group isn't just another contractor\u2014we're a true operating partner committed to changing the way mining companies approach their operations. We develop our people. We partner transparently with our clients. We believe in win, win, win.<\/p>\n<p>We are looking for a dynamic and talented Marketing Manager for our fast-growing, forward-thinking mining services company headquartered in Bloomington.<\/p>\n<p>This full-time, tactical marketing role will be responsible for day-to-day execution of marketing programs, content creation, and campaign management. The Marketing Manager will implement the strategic direction provided by the CMO while managing operational marketing activities that support Turner Mining Group's growth objectives. This role will work collaboratively with the CMO and other members of the Turner Mining Group team.<\/p>\n<p><strong>Key Responsibilities<\/strong><\/p>\n<p><strong>Content Creation &amp; Management<\/strong><\/p>\n<ul>\n <li>Develop and execute content calendar across all channels      (blog, social media, email, web)<\/li>\n <li>Create tactical marketing materials including brochures, case      studies, and sales collateral<\/li>\n <li>Coordinate with operations teams to capture project success      stories and testimonials and draft up written content for review<\/li>\n <li>Spearhead day-to-day website content updates, maintenance,      and technical operations<\/li>\n<\/ul>\n<p><strong>Campaign Execution &amp; Event Management<\/strong><\/p>\n<ul>\n <li>Execute integrated marketing campaigns promoting Turner\u2019s      evolved brand<\/li>\n <li>Coordinate trade show participation including booth      management, materials, and follow-up<\/li>\n <li>Manage webinar planning, promotion, and execution<\/li>\n <li>Support industry event participation and sponsorship      activations<\/li>\n<\/ul>\n<p><strong>Sales Support &amp; Marketing Operations<\/strong><\/p>\n<ul>\n <li>Create and maintain sales enablement materials and      presentations<\/li>\n <li>Develop modular content for sales team as needed<\/li>\n <li>Create prospect-specific marketing materials to aid in      pursuits<\/li>\n <li>Manage CRM marketing activities in HubSpot<\/li>\n<\/ul>\n<p><strong>Podcast Production &amp; Content Distribution<\/strong><\/p>\n<ul>\n <li>Manage Turner Mining Live podcast production, scheduling, and      guest coordination<\/li>\n <li>Create promotional materials and social media content for      Turner Mining Live <\/li>\n <li>Develop content repurposing strategies (blog posts, social      clips, articles from podcast content)<\/li>\n <li>Manage podcast analytics and audience development initiatives<\/li>\n<\/ul>\n<p><strong>Company Store &amp; Merchandise Management<\/strong><\/p>\n<ul>\n <li>Oversee Turner Mining Group company store operations and      inventory<\/li>\n <li>Develop new merchandise concepts and manage vendor      relationships<\/li>\n <li>Create promotional campaigns for branded merchandise and      giveaways<\/li>\n <li>Manage e-commerce functionality and customer service for      store operations<\/li>\n <li>Coordinate branded merchandise for trade shows and client      meetings<\/li>\n<\/ul>\n<p><strong>Public Relations &amp; Communications<\/strong><\/p>\n<ul>\n <li>Execute press release development and distribution<\/li>\n <li>Maintain media contact database and industry publication      relationships<\/li>\n <li>Support speaking opportunity applications and conference      submissions<\/li>\n <li>Coordinate internal communications and marketing updates<\/li>\n <li>Handle routine marketing communications and inquiries<\/li>\n<\/ul>\n<p><strong>Required Qualifications<\/strong><\/p>\n<ul>\n <li>3-5 years of marketing experience, preferably in B2B      industrial or construction sectors<\/li>\n <li>Strong content creation skills including writing, design, and      basic video production<\/li>\n <li>Experience with digital marketing platforms (LinkedIn, Google      Ads, marketing automation)<\/li>\n <li>Proficiency in marketing technology tools (CMS, CRM, design      software, analytics)<\/li>\n <li>Excellent project management and organizational skills<\/li>\n <li>Understanding of B2B sales processes and lead generation      strategies<\/li>\n<\/ul>\n<p><strong>Preferred Qualifications<\/strong><\/p>\n<ul>\n <li>Experience in mining, construction, or heavy industrial      equipment sectors<\/li>\n <ul>\n  <li>Basic understanding of mining operations and terminology is       a plus<\/li>\n <\/ul>\n <li>Familiarity with trade show management and industry event      coordination<\/li>\n <li>Experience supporting complex, consultative sales processes<\/li>\n <li>Podcast production and audio content experience preferred<\/li>\n <li>E-commerce and retail merchandise management experience<\/li>\n<\/ul>\n<p><strong>Location<\/strong><\/p>\n<ul>\n <li>Onsite \u2013 Bloomington, Indiana<\/li>\n<\/ul>","post_title":"Marketing Manager","post_link":"https:\/\/turnerstaffing.com\/position\/marketing-manager\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Associate","%location_country%":"United States","%location_city%":"Bloomington","%location_state_id%":"IN","%location_state_name%":"Indiana","%location_city_state%":"Bloomington, IN","%education%":"Bachelor's Degree","%department%":"Marketing","%description%":"<p><strong>Marketing Manager<\/strong><\/p>\n<p><strong>Overview<\/strong><\/p>\n<p><strong>Do you believe marketing should drive real results? Do you think differently about partnership-driven growth? Are you ready to help redefine how the mining industry does business?<\/strong><\/p>\n<p><strong>We've been waiting for you!<\/strong> Turner Mining Group isn't just another contractor\u2014we're a true operating partner committed to changing the way mining companies approach their operations. We develop our people. We partner transparently with our clients. We believe in win, win, win.<\/p>\n<p>We are looking for a dynamic and talented Marketing Manager for our fast-growing, forward-thinking mining services company headquartered in Bloomington.<\/p>\n<p>This full-time, tactical marketing role will be responsible for day-to-day execution of marketing programs, content creation, and campaign management. The Marketing Manager will implement the strategic direction provided by the CMO while managing operational marketing activities that support Turner Mining Group's growth objectives. This role will work collaboratively with the CMO and other members of the Turner Mining Group team.<\/p>\n<p><strong>Key Responsibilities<\/strong><\/p>\n<p><strong>Content Creation &amp; Management<\/strong><\/p>\n<ul>\n <li>Develop and execute content calendar across all channels      (blog, social media, email, web)<\/li>\n <li>Create tactical marketing materials including brochures, case      studies, and sales collateral<\/li>\n <li>Coordinate with operations teams to capture project success      stories and testimonials and draft up written content for review<\/li>\n <li>Spearhead day-to-day website content updates, maintenance,      and technical operations<\/li>\n<\/ul>\n<p><strong>Campaign Execution &amp; Event Management<\/strong><\/p>\n<ul>\n <li>Execute integrated marketing campaigns promoting Turner\u2019s      evolved brand<\/li>\n <li>Coordinate trade show participation including booth      management, materials, and follow-up<\/li>\n <li>Manage webinar planning, promotion, and execution<\/li>\n <li>Support industry event participation and sponsorship      activations<\/li>\n<\/ul>\n<p><strong>Sales Support &amp; Marketing Operations<\/strong><\/p>\n<ul>\n <li>Create and maintain sales enablement materials and      presentations<\/li>\n <li>Develop modular content for sales team as needed<\/li>\n <li>Create prospect-specific marketing materials to aid in      pursuits<\/li>\n <li>Manage CRM marketing activities in HubSpot<\/li>\n<\/ul>\n<p><strong>Podcast Production &amp; Content Distribution<\/strong><\/p>\n<ul>\n <li>Manage Turner Mining Live podcast production, scheduling, and      guest coordination<\/li>\n <li>Create promotional materials and social media content for      Turner Mining Live <\/li>\n <li>Develop content repurposing strategies (blog posts, social      clips, articles from podcast content)<\/li>\n <li>Manage podcast analytics and audience development initiatives<\/li>\n<\/ul>\n<p><strong>Company Store &amp; Merchandise Management<\/strong><\/p>\n<ul>\n <li>Oversee Turner Mining Group company store operations and      inventory<\/li>\n <li>Develop new merchandise concepts and manage vendor      relationships<\/li>\n <li>Create promotional campaigns for branded merchandise and      giveaways<\/li>\n <li>Manage e-commerce functionality and customer service for      store operations<\/li>\n <li>Coordinate branded merchandise for trade shows and client      meetings<\/li>\n<\/ul>\n<p><strong>Public Relations &amp; Communications<\/strong><\/p>\n<ul>\n <li>Execute press release development and distribution<\/li>\n <li>Maintain media contact database and industry publication      relationships<\/li>\n <li>Support speaking opportunity applications and conference      submissions<\/li>\n <li>Coordinate internal communications and marketing updates<\/li>\n <li>Handle routine marketing communications and inquiries<\/li>\n<\/ul>\n<p><strong>Required Qualifications<\/strong><\/p>\n<ul>\n <li>3-5 years of marketing experience, preferably in B2B      industrial or construction sectors<\/li>\n <li>Strong content creation skills including writing, design, and      basic video production<\/li>\n <li>Experience with digital marketing platforms (LinkedIn, Google      Ads, marketing automation)<\/li>\n <li>Proficiency in marketing technology tools (CMS, CRM, design      software, analytics)<\/li>\n <li>Excellent project management and organizational skills<\/li>\n <li>Understanding of B2B sales processes and lead generation      strategies<\/li>\n<\/ul>\n<p><strong>Preferred Qualifications<\/strong><\/p>\n<ul>\n <li>Experience in mining, construction, or heavy industrial      equipment sectors<\/li>\n <ul>\n  <li>Basic understanding of mining operations and terminology is       a plus<\/li>\n <\/ul>\n <li>Familiarity with trade show management and industry event      coordination<\/li>\n <li>Experience supporting complex, consultative sales processes<\/li>\n <li>Podcast production and audio content experience preferred<\/li>\n <li>E-commerce and retail merchandise management experience<\/li>\n<\/ul>\n<p><strong>Location<\/strong><\/p>\n<ul>\n <li>Onsite \u2013 Bloomington, Indiana<\/li>\n<\/ul>","%category%":"Marketing","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/9eb56ba55ece-marketing-manager","%breezy_id%":"9eb56ba55ece","%breezy_friendly_id%":"9eb56ba55ece-marketing-manager","%breezy_created_date%":"2025-09-23T15:55:49.094Z","%breezy_updated_date%":"2025-09-23T15:57:11.880Z","%_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":2781,"infowindow_disable":false},{"source":"post","title":"Excavator Operator","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Excavator Operator\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Turner Staffing Group \u2013 Excavator Operator Do you love mining? Do you think differently? Are you ready to define the&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/excavator-operator-7\/\" name=\"Excavator Operator\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Turner Staffing Group \u2013 Excavator Operator Do you love mining? Do you think differently? Are you ready to define the&hellip;","address":"Bechtelsville, PA, USA","location":{"lat":"40.3734297","city":"Bechtelsville","state":"PA","country":"United States","lng":"-75.6290752","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/excavator-operator-7\/","zoom":19,"extra_fields":{"post_excerpt":"Turner Staffing Group \u2013 Excavator Operator Do you love mining? Do you think differently? Are you ready to define the&hellip;","post_content":"<p><strong><u>Turner Staffing Group \u2013 Excavator 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.<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 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 excavators and other pieces of heavy equipment in a production environment<\/li><li>Performing all pre-shift inspections, some basic maintenance and upkeep<\/li><li>Working with teammates on crew to maximize production while always maintaining our safety rules and regulations.<\/li><\/ul>\n<p><strong>Requirements:<\/strong><\/p>\n<ul><li>Safety oriented, awareness of everyone and everything that is around you<\/li><li>Strong work ethic<\/li><li>Willingness to learn<\/li><li>Ability to be flexible and to adapt<\/li><li>Experience with heavy equipment<\/li><li>Preferred to have MSHA training<\/li><\/ul>\n<p><\/p>","post_title":"Excavator Operator","post_link":"https:\/\/turnerstaffing.com\/position\/excavator-operator-7\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Contract","%experience%":"","%location_country%":"United States","%location_city%":"Bechtelsville","%location_state_id%":"PA","%location_state_name%":"Pennsylvania","%location_city_state%":"Bechtelsville, PA","%education%":"","%department%":"","%description%":"<p><strong><u>Turner Staffing Group \u2013 Excavator 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.<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 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 excavators and other pieces of heavy equipment in a production environment<\/li><li>Performing all pre-shift inspections, some basic maintenance and upkeep<\/li><li>Working with teammates on crew to maximize production while always maintaining our safety rules and regulations.<\/li><\/ul>\n<p><strong>Requirements:<\/strong><\/p>\n<ul><li>Safety oriented, awareness of everyone and everything that is around you<\/li><li>Strong work ethic<\/li><li>Willingness to learn<\/li><li>Ability to be flexible and to adapt<\/li><li>Experience with heavy equipment<\/li><li>Preferred to have MSHA training<\/li><\/ul>\n<p><\/p>","%category%":"","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/26b881047c87-excavator-operator","%breezy_id%":"26b881047c87","%breezy_friendly_id%":"26b881047c87-excavator-operator","%breezy_created_date%":"2025-07-22T15:52:56.386Z","%breezy_updated_date%":"2025-09-22T17:15:14.813Z","%_wpgmp_location_city%":"Bechtelsville","%_wpgmp_location_state%":"PA","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Bechtelsville, PA, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"40.3734297","%_wpgmp_metabox_longitude%":"-75.6290752","%rank_math_internal_links_processed%":"1"}},"id":2779,"infowindow_disable":false},{"source":"post","title":"Mining Plant Operator","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Mining Plant Operator\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Turner Staffing Group \u2013 Plant Operator Turner Staffing Group is seeking an energetic mining professionals who can leverage their mining&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/mining-plant-operator\/\" name=\"Mining Plant Operator\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Turner Staffing Group \u2013 Plant Operator Turner Staffing Group is seeking an energetic mining professionals who can leverage their mining&hellip;","address":"Bechtelsville, PA, USA","location":{"lat":"40.3734297","city":"Bechtelsville","state":"PA","country":"United States","lng":"-75.6290752","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/mining-plant-operator\/","zoom":19,"extra_fields":{"post_excerpt":"Turner Staffing Group \u2013 Plant Operator Turner Staffing Group is seeking an energetic mining professionals who can leverage their mining&hellip;","post_content":"<p><strong><u>Turner Staffing Group \u2013 Plant Operator<\/u><\/strong><br><\/p>\n\n<p>Turner Staffing Group is seeking an energetic mining professionals who can leverage their mining knowledge to expand upon our fast-growing business, creating best practices for equipment operations to ensure profitable operations.<\/p>\n<p><strong>You<\/strong><\/p>\n<p>You want to work for a services company that is rapidly changing the way the largest materials producers do business. You are motivated by solving problems and partnering with our clients and suppliers. You want to work with great people and enjoy being a part of a strong team. You are a safety oriented, hard working individual who is not afraid to jump into every detail. You want to be in a place where continuous learning and growth is the norm. You are adaptable and able to juggle multiple initiatives concurrently.<\/p>\n<p><strong>Responsibilities:<\/strong><\/p>\n<ul><li>Monitor the stationary plant feeder for ongoing maintenance needs<\/li><li>Operator heavy equipment as needed<\/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><br><\/p>","post_title":"Mining Plant Operator","post_link":"https:\/\/turnerstaffing.com\/position\/mining-plant-operator\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"","%location_country%":"United States","%location_city%":"Bechtelsville","%location_state_id%":"PA","%location_state_name%":"Pennsylvania","%location_city_state%":"Bechtelsville, PA","%education%":"","%department%":"","%description%":"<p><strong><u>Turner Staffing Group \u2013 Plant Operator<\/u><\/strong><br><\/p>\n\n<p>Turner Staffing Group is seeking an energetic mining professionals who can leverage their mining knowledge to expand upon our fast-growing business, creating best practices for equipment operations to ensure profitable operations.<\/p>\n<p><strong>You<\/strong><\/p>\n<p>You want to work for a services company that is rapidly changing the way the largest materials producers do business. You are motivated by solving problems and partnering with our clients and suppliers. You want to work with great people and enjoy being a part of a strong team. You are a safety oriented, hard working individual who is not afraid to jump into every detail. You want to be in a place where continuous learning and growth is the norm. You are adaptable and able to juggle multiple initiatives concurrently.<\/p>\n<p><strong>Responsibilities:<\/strong><\/p>\n<ul><li>Monitor the stationary plant feeder for ongoing maintenance needs<\/li><li>Operator heavy equipment as needed<\/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><br><\/p>","%category%":"","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/74230ff6c246-mining-plant-operator","%breezy_id%":"74230ff6c246","%breezy_friendly_id%":"74230ff6c246-mining-plant-operator","%breezy_created_date%":"2025-07-22T15:58:14.127Z","%breezy_updated_date%":"2025-09-22T17:15:18.209Z","%_wpgmp_location_city%":"Bechtelsville","%_wpgmp_location_state%":"PA","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Bechtelsville, PA, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"40.3734297","%_wpgmp_metabox_longitude%":"-75.6290752","%rank_math_internal_links_processed%":"1"}},"id":2780,"infowindow_disable":false},{"source":"post","title":"Grader Operator","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Grader Operator\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Turner Staffing Group \u2013 Grader Operator Do you love the dirt world? Do you think differently? Are you ready to&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/grader-operator\/\" name=\"Grader Operator\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Turner Staffing Group \u2013 Grader Operator Do you love the dirt world? Do you think differently? Are you ready to&hellip;","address":"Scranton, PA, USA","location":{"lat":"41.410314","city":"Scranton","state":"PA","country":"United States","lng":"-75.661099","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/grader-operator\/","zoom":19,"extra_fields":{"post_excerpt":"Turner Staffing Group \u2013 Grader Operator Do you love the dirt world? Do you think differently? Are you ready to&hellip;","post_content":"<p><strong><u>Turner Staffing Group \u2013 Grader Operator<\/u><\/strong><\/p>\n<p>Do you love the dirt world? Do you think differently? Are you ready to define the future of this industry?<\/p>\n<p>We\u2019ve been waiting for you! Turner Staffing Group is committed to changing the way civil construction companies do business. We develop our people. We partner with our clients. We believe in win, win, win.<\/p>\n<p>We are looking for a dynamic and talented Grader Operators for our fast-growing, forward thinking client based in the Scranton area.<br><\/p>\n<p><strong>You<\/strong><\/p>\n<p>You want to work for a services company that is rapidly changing the way the largest construction firms do business. You are motivated by solving problems and partnering with our clients and suppliers. You want to work with great people and enjoy being a part of a strong team. You are a knowledgeable Operator who is not afraid to jump into every detail. You want to be in a place where continuous learning and growth is the norm. You are adaptable and able to juggle multiple initiatives concurrently.<\/p>\n<p><strong>Responsibilities:<\/strong><\/p>\n<ul><li>Operating graders in a civil construction environment<\/li><li>Performing all pre-shift inspections, some basic maintenance and upkeep<\/li><li>Working with teammates on crew to maximize production while always maintaining our safety rules and regulations.<\/li><\/ul>\n<p><strong>Requirements:<\/strong><\/p>\n<ul><li>Safety oriented, awareness of everyone and everything that is around you<\/li><li>Strong work ethic<\/li><li>Willingness to learn<\/li><li>Ability to be flexible and to adapt<\/li><li>Experience with heavy equipment<\/li><li>Preferred to have OSHA training<\/li><\/ul>","post_title":"Grader Operator","post_link":"https:\/\/turnerstaffing.com\/position\/grader-operator\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Mid Level","%location_country%":"United States","%location_city%":"Scranton","%location_state_id%":"PA","%location_state_name%":"Pennsylvania","%location_city_state%":"Scranton, PA","%education%":"Unspecified","%department%":"","%description%":"<p><strong><u>Turner Staffing Group \u2013 Grader Operator<\/u><\/strong><\/p>\n<p>Do you love the dirt world? Do you think differently? Are you ready to define the future of this industry?<\/p>\n<p>We\u2019ve been waiting for you! Turner Staffing Group is committed to changing the way civil construction companies do business. We develop our people. We partner with our clients. We believe in win, win, win.<\/p>\n<p>We are looking for a dynamic and talented Grader Operators for our fast-growing, forward thinking client based in the Scranton area.<br><\/p>\n<p><strong>You<\/strong><\/p>\n<p>You want to work for a services company that is rapidly changing the way the largest construction firms do business. You are motivated by solving problems and partnering with our clients and suppliers. You want to work with great people and enjoy being a part of a strong team. You are a knowledgeable Operator who is not afraid to jump into every detail. You want to be in a place where continuous learning and growth is the norm. You are adaptable and able to juggle multiple initiatives concurrently.<\/p>\n<p><strong>Responsibilities:<\/strong><\/p>\n<ul><li>Operating graders in a civil construction environment<\/li><li>Performing all pre-shift inspections, some basic maintenance and upkeep<\/li><li>Working with teammates on crew to maximize production while always maintaining our safety rules and regulations.<\/li><\/ul>\n<p><strong>Requirements:<\/strong><\/p>\n<ul><li>Safety oriented, awareness of everyone and everything that is around you<\/li><li>Strong work ethic<\/li><li>Willingness to learn<\/li><li>Ability to be flexible and to adapt<\/li><li>Experience with heavy equipment<\/li><li>Preferred to have OSHA training<\/li><\/ul>","%category%":"Operations","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/f50a8f0e9925-grader-operator","%breezy_id%":"f50a8f0e9925","%breezy_friendly_id%":"f50a8f0e9925-grader-operator","%breezy_created_date%":"2025-04-03T18:55:19.763Z","%breezy_updated_date%":"2025-09-22T18:35:58.516Z","%_wpgmp_location_city%":"Scranton","%_wpgmp_location_state%":"PA","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Scranton, PA, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"41.410314","%_wpgmp_metabox_longitude%":"-75.661099","%rank_math_internal_links_processed%":"1"}},"id":2777,"infowindow_disable":false},{"source":"post","title":"Haul Truck Driver","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Haul Truck Driver\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Turner Staffing Group \u2013 Haul Truck Driver Do you love the dirt world? Do you think differently? Are you ready&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/haul-truck-driver-13\/\" name=\"Haul Truck Driver\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Turner Staffing Group \u2013 Haul Truck Driver Do you love the dirt world? Do you think differently? Are you ready&hellip;","address":"Scranton, PA, USA","location":{"lat":"41.410314","city":"Scranton","state":"PA","country":"United States","lng":"-75.661099","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/haul-truck-driver-13\/","zoom":19,"extra_fields":{"post_excerpt":"Turner Staffing Group \u2013 Haul Truck Driver Do you love the dirt world? Do you think differently? Are you ready&hellip;","post_content":"<p><strong><u>Turner Staffing Group \u2013 Haul Truck Driver<\/u><\/strong><\/p>\n<p>Do you love the dirt world? Do you think differently? Are you ready to define the future of this industry?<\/p>\n<p>We\u2019ve been waiting for you! Turner Staffing Group is committed to changing the way civil construction companies do business. We develop our people. We partner with our clients. We believe in win, win, win.<\/p>\n<p>We are looking for a dynamic and talented Haul Truck Drivers for our fast-growing, forward thinking client based in the Scranton area.<br><\/p>\n<p><strong>You<\/strong><\/p>\n<p>You want to work for a services company that is rapidly changing the way the largest construction firms do business. You are motivated by solving problems and partnering with our clients and suppliers. You want to work with great people and enjoy being a part of a strong team. You are a knowledgeable Operator who is not afraid to jump into every detail. You want to be in a place where continuous learning and growth is the norm. You are adaptable and able to juggle multiple initiatives concurrently.<\/p>\n<p><strong>Responsibilities:<\/strong><\/p>\n<ul><li>Operating haul trucks in a civil construction environment<\/li><li>Performing all pre-shift inspections, some basic maintenance and upkeep<\/li><li>Working with teammates on crew to maximize production while always maintaining our safety rules and regulations.<\/li><\/ul>\n<p><strong>Requirements:<\/strong><\/p>\n<ul><li>Safety oriented, awareness of everyone and everything that is around you<\/li><li>Strong work ethic<\/li><li>Willingness to learn<\/li><li>Ability to be flexible and to adapt<\/li><li>Experience with heavy equipment<\/li><li>Preferred to have OSHA training<\/li><\/ul>","post_title":"Haul Truck Driver","post_link":"https:\/\/turnerstaffing.com\/position\/haul-truck-driver-13\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Mid Level","%location_country%":"United States","%location_city%":"Scranton","%location_state_id%":"PA","%location_state_name%":"Pennsylvania","%location_city_state%":"Scranton, PA","%education%":"Unspecified","%department%":"","%description%":"<p><strong><u>Turner Staffing Group \u2013 Haul Truck Driver<\/u><\/strong><\/p>\n<p>Do you love the dirt world? Do you think differently? Are you ready to define the future of this industry?<\/p>\n<p>We\u2019ve been waiting for you! Turner Staffing Group is committed to changing the way civil construction companies do business. We develop our people. We partner with our clients. We believe in win, win, win.<\/p>\n<p>We are looking for a dynamic and talented Haul Truck Drivers for our fast-growing, forward thinking client based in the Scranton area.<br><\/p>\n<p><strong>You<\/strong><\/p>\n<p>You want to work for a services company that is rapidly changing the way the largest construction firms do business. You are motivated by solving problems and partnering with our clients and suppliers. You want to work with great people and enjoy being a part of a strong team. You are a knowledgeable Operator who is not afraid to jump into every detail. You want to be in a place where continuous learning and growth is the norm. You are adaptable and able to juggle multiple initiatives concurrently.<\/p>\n<p><strong>Responsibilities:<\/strong><\/p>\n<ul><li>Operating haul trucks in a civil construction environment<\/li><li>Performing all pre-shift inspections, some basic maintenance and upkeep<\/li><li>Working with teammates on crew to maximize production while always maintaining our safety rules and regulations.<\/li><\/ul>\n<p><strong>Requirements:<\/strong><\/p>\n<ul><li>Safety oriented, awareness of everyone and everything that is around you<\/li><li>Strong work ethic<\/li><li>Willingness to learn<\/li><li>Ability to be flexible and to adapt<\/li><li>Experience with heavy equipment<\/li><li>Preferred to have OSHA training<\/li><\/ul>","%category%":"Operations","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/6e43f77d261e-haul-truck-driver","%breezy_id%":"6e43f77d261e","%breezy_friendly_id%":"6e43f77d261e-haul-truck-driver","%breezy_created_date%":"2025-04-03T18:56:29.561Z","%breezy_updated_date%":"2025-09-22T18:35:59.102Z","%_wpgmp_location_city%":"Scranton","%_wpgmp_location_state%":"PA","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Scranton, PA, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"41.410314","%_wpgmp_metabox_longitude%":"-75.661099","%rank_math_internal_links_processed%":"1"}},"id":2778,"infowindow_disable":false},{"source":"post","title":"Dozer Operator","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Dozer Operator\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Turner Staffing Group \u2013 Dozer Operator Do you love the dirt world? Do you think differently? Are you ready to&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/dozer-operator-7\/\" name=\"Dozer Operator\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Turner Staffing Group \u2013 Dozer Operator Do you love the dirt world? Do you think differently? Are you ready to&hellip;","address":"Scranton, PA, USA","location":{"lat":"41.410314","city":"Scranton","state":"PA","country":"United States","lng":"-75.661099","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/dozer-operator-7\/","zoom":19,"extra_fields":{"post_excerpt":"Turner Staffing Group \u2013 Dozer Operator Do you love the dirt world? Do you think differently? Are you ready to&hellip;","post_content":"<p><strong><u>Turner Staffing Group \u2013 Dozer Operator<\/u><\/strong><\/p>\n<p>Do you love the dirt world? Do you think differently? Are you ready to define the future of this industry?<\/p>\n<p>We\u2019ve been waiting for you! Turner Staffing Group is committed to changing the way civil construction&nbsp;companies do business. We develop our people. We partner with our clients. We believe in win, win, win.<\/p>\n<p>We are looking for a dynamic and talented Dozer Operators for our fast-growing, forward thinking client based&nbsp;in the Scranton area.<br><\/p>\n<p><strong>You<\/strong><\/p>\n<p>You want to work for a services company that is rapidly changing the way the largest construction firms&nbsp;do business. You are motivated by solving problems and partnering with our clients and suppliers. You want to work with great people and enjoy being a part of a strong team. You are a knowledgeable Operator who is not afraid to jump into every detail. You want to be in a place where continuous learning and growth is the norm. You are adaptable and able to juggle multiple initiatives concurrently.<\/p>\n<p><strong>Responsibilities:<\/strong><\/p>\n<ul><li>Operating excavators in a civil construction&nbsp;environment<\/li><li>Performing all pre-shift inspections, some basic maintenance and upkeep<\/li><li>Working with teammates on crew to maximize production while always maintaining our safety rules and regulations.<\/li><\/ul>\n<p><strong>Requirements:<\/strong><\/p>\n<ul><li>Safety oriented, awareness of everyone and everything that is around you<\/li><li>Strong work ethic<\/li><li>Willingness to learn<\/li><li>Ability to be flexible and to adapt<\/li><li>Experience with heavy equipment<\/li><li>Preferred to have OSHA training<\/li><\/ul>","post_title":"Dozer Operator","post_link":"https:\/\/turnerstaffing.com\/position\/dozer-operator-7\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Mid Level","%location_country%":"United States","%location_city%":"Scranton","%location_state_id%":"PA","%location_state_name%":"Pennsylvania","%location_city_state%":"Scranton, PA","%education%":"Unspecified","%department%":"","%description%":"<p><strong><u>Turner Staffing Group \u2013 Dozer Operator<\/u><\/strong><\/p>\n<p>Do you love the dirt world? Do you think differently? Are you ready to define the future of this industry?<\/p>\n<p>We\u2019ve been waiting for you! Turner Staffing Group is committed to changing the way civil construction&nbsp;companies do business. We develop our people. We partner with our clients. We believe in win, win, win.<\/p>\n<p>We are looking for a dynamic and talented Dozer Operators for our fast-growing, forward thinking client based&nbsp;in the Scranton area.<br><\/p>\n<p><strong>You<\/strong><\/p>\n<p>You want to work for a services company that is rapidly changing the way the largest construction firms&nbsp;do business. You are motivated by solving problems and partnering with our clients and suppliers. You want to work with great people and enjoy being a part of a strong team. You are a knowledgeable Operator who is not afraid to jump into every detail. You want to be in a place where continuous learning and growth is the norm. You are adaptable and able to juggle multiple initiatives concurrently.<\/p>\n<p><strong>Responsibilities:<\/strong><\/p>\n<ul><li>Operating excavators in a civil construction&nbsp;environment<\/li><li>Performing all pre-shift inspections, some basic maintenance and upkeep<\/li><li>Working with teammates on crew to maximize production while always maintaining our safety rules and regulations.<\/li><\/ul>\n<p><strong>Requirements:<\/strong><\/p>\n<ul><li>Safety oriented, awareness of everyone and everything that is around you<\/li><li>Strong work ethic<\/li><li>Willingness to learn<\/li><li>Ability to be flexible and to adapt<\/li><li>Experience with heavy equipment<\/li><li>Preferred to have OSHA training<\/li><\/ul>","%category%":"Operations","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/ce8924b823bc-dozer-operator","%breezy_id%":"ce8924b823bc","%breezy_friendly_id%":"ce8924b823bc-dozer-operator","%breezy_created_date%":"2025-04-03T18:30:05.657Z","%breezy_updated_date%":"2025-09-22T18:35:57.081Z","%_wpgmp_location_city%":"Scranton","%_wpgmp_location_state%":"PA","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Scranton, PA, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"41.410314","%_wpgmp_metabox_longitude%":"-75.661099","%rank_math_internal_links_processed%":"1"}},"id":2774,"infowindow_disable":false},{"source":"post","title":"Construction Laborer","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Construction Laborer\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Turner Staffing Group \u2013 Construction Laborer Do you love the dirt world? Do you think differently? Are you ready to&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/construction-laborer-2\/\" name=\"Construction Laborer\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Turner Staffing Group \u2013 Construction Laborer Do you love the dirt world? Do you think differently? Are you ready to&hellip;","address":"Scranton, PA, USA","location":{"lat":"41.410314","city":"Scranton","state":"PA","country":"United States","lng":"-75.661099","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/construction-laborer-2\/","zoom":19,"extra_fields":{"post_excerpt":"Turner Staffing Group \u2013 Construction Laborer Do you love the dirt world? Do you think differently? Are you ready to&hellip;","post_content":"<p><strong><u>Turner Staffing Group \u2013 Construction Laborer<\/u><\/strong><\/p>\n<p>Do you love the dirt world? Do you think differently? Are you ready to define the future of this industry?<\/p>\n<p>We\u2019ve been waiting for you! Turner Staffing Group is committed to changing the way civil construction companies do business. We develop our people. We partner with our clients. We believe in win, win, win.<\/p>\n<p>We are looking for a dynamic and talented Construction Laborers for our fast-growing, forward thinking client based in the Scranton area.<br><\/p>\n<p><strong>You<\/strong><\/p>\n<p>You want to work for a services company that is rapidly changing the way the largest construction firms do business. You are motivated by solving problems and partnering with our clients and suppliers. You want to work with great people and enjoy being a part of a strong team. You are a knowledgeable individual who is not afraid to jump into every detail. You want to be in a place where continuous learning and growth is the norm. You are adaptable and able to juggle multiple initiatives concurrently.<\/p>\n<p><strong>Responsibilities:<\/strong><\/p>\n<ul><li>Performing tasks as directed by management&nbsp;in a civil construction environment<\/li><li>Assist in basic maintenance and upkeep of equipment<\/li><li>Working with teammates on crew to maximize production while always maintaining our safety rules and regulations.<\/li><\/ul>\n<p><strong>Requirements:<\/strong><\/p>\n<ul><li>Safety oriented, awareness of everyone and everything that is around you<\/li><li>Strong work ethic<\/li><li>Willingness to learn<\/li><li>Ability to be flexible and to adapt<\/li><li>Experience with heavy equipment is a plus<\/li><li>Preferred to have OSHA training<\/li><\/ul>","post_title":"Construction Laborer","post_link":"https:\/\/turnerstaffing.com\/position\/construction-laborer-2\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Associate","%location_country%":"United States","%location_city%":"Scranton","%location_state_id%":"PA","%location_state_name%":"Pennsylvania","%location_city_state%":"Scranton, PA","%education%":"Unspecified","%department%":"","%description%":"<p><strong><u>Turner Staffing Group \u2013 Construction Laborer<\/u><\/strong><\/p>\n<p>Do you love the dirt world? Do you think differently? Are you ready to define the future of this industry?<\/p>\n<p>We\u2019ve been waiting for you! Turner Staffing Group is committed to changing the way civil construction companies do business. We develop our people. We partner with our clients. We believe in win, win, win.<\/p>\n<p>We are looking for a dynamic and talented Construction Laborers for our fast-growing, forward thinking client based in the Scranton area.<br><\/p>\n<p><strong>You<\/strong><\/p>\n<p>You want to work for a services company that is rapidly changing the way the largest construction firms do business. You are motivated by solving problems and partnering with our clients and suppliers. You want to work with great people and enjoy being a part of a strong team. You are a knowledgeable individual who is not afraid to jump into every detail. You want to be in a place where continuous learning and growth is the norm. You are adaptable and able to juggle multiple initiatives concurrently.<\/p>\n<p><strong>Responsibilities:<\/strong><\/p>\n<ul><li>Performing tasks as directed by management&nbsp;in a civil construction environment<\/li><li>Assist in basic maintenance and upkeep of equipment<\/li><li>Working with teammates on crew to maximize production while always maintaining our safety rules and regulations.<\/li><\/ul>\n<p><strong>Requirements:<\/strong><\/p>\n<ul><li>Safety oriented, awareness of everyone and everything that is around you<\/li><li>Strong work ethic<\/li><li>Willingness to learn<\/li><li>Ability to be flexible and to adapt<\/li><li>Experience with heavy equipment is a plus<\/li><li>Preferred to have OSHA training<\/li><\/ul>","%category%":"Operations","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/aecf8d1a87ba-construction-laborer","%breezy_id%":"aecf8d1a87ba","%breezy_friendly_id%":"aecf8d1a87ba-construction-laborer","%breezy_created_date%":"2025-04-03T18:31:18.437Z","%breezy_updated_date%":"2025-09-22T18:35:56.383Z","%_wpgmp_location_city%":"Scranton","%_wpgmp_location_state%":"PA","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Scranton, PA, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"41.410314","%_wpgmp_metabox_longitude%":"-75.661099","%rank_math_internal_links_processed%":"1"}},"id":2775,"infowindow_disable":false},{"source":"post","title":"Excavator Operator","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Excavator Operator\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Turner Staffing Group \u2013 Excavator Operator Do you love the dirt world? Do you think differently? Are you ready to&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/excavator-operator-6\/\" name=\"Excavator Operator\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Turner Staffing Group \u2013 Excavator Operator Do you love the dirt world? Do you think differently? Are you ready to&hellip;","address":"Scranton, PA, USA","location":{"lat":"41.410314","city":"Scranton","state":"PA","country":"United States","lng":"-75.661099","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/excavator-operator-6\/","zoom":19,"extra_fields":{"post_excerpt":"Turner Staffing Group \u2013 Excavator Operator Do you love the dirt world? Do you think differently? Are you ready to&hellip;","post_content":"<p><strong><u>Turner Staffing Group \u2013 Excavator Operator<\/u><\/strong><\/p>\n<p>Do you love the dirt world? Do you think differently? Are you ready to define the future of this industry?<\/p>\n<p>We\u2019ve been waiting for you! Turner Staffing Group is committed to changing the way civil construction&nbsp;companies do business. We develop our people. We partner with our clients. We believe in win, win, win.<\/p>\n<p>We are looking for a dynamic and talented Excavator Operators for our fast-growing, forward thinking client based in the Scranton area.<br><\/p>\n<p><strong>You<\/strong><\/p>\n<p>You want to work for a services company that is rapidly changing the way the largest construction firms do business. You are motivated by solving problems and partnering with our clients and suppliers. You want to work with great people and enjoy being a part of a strong team. You are a knowledgeable Operator who is not afraid to jump into every detail. You want to be in a place where continuous learning and growth is the norm. You are adaptable and able to juggle multiple initiatives concurrently.<\/p>\n<p><strong>Responsibilities:<\/strong><\/p>\n<ul><li>Operating excavators in a civil construction environment<\/li><li>Performing all pre-shift inspections, some basic maintenance and upkeep<\/li><li>Working with teammates on crew to maximize production while always maintaining our safety rules and regulations.<\/li><\/ul>\n<p><strong>Requirements:<\/strong><\/p>\n<ul><li>Safety oriented, awareness of everyone and everything that is around you<\/li><li>Strong work ethic<\/li><li>Willingness to learn<\/li><li>Ability to be flexible and to adapt<\/li><li>Experience with heavy equipment<\/li><li>Preferred to have OSHA training<\/li><\/ul>","post_title":"Excavator Operator","post_link":"https:\/\/turnerstaffing.com\/position\/excavator-operator-6\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Mid Level","%location_country%":"United States","%location_city%":"Scranton","%location_state_id%":"PA","%location_state_name%":"Pennsylvania","%location_city_state%":"Scranton, PA","%education%":"Unspecified","%department%":"","%description%":"<p><strong><u>Turner Staffing Group \u2013 Excavator Operator<\/u><\/strong><\/p>\n<p>Do you love the dirt world? Do you think differently? Are you ready to define the future of this industry?<\/p>\n<p>We\u2019ve been waiting for you! Turner Staffing Group is committed to changing the way civil construction&nbsp;companies do business. We develop our people. We partner with our clients. We believe in win, win, win.<\/p>\n<p>We are looking for a dynamic and talented Excavator Operators for our fast-growing, forward thinking client based in the Scranton area.<br><\/p>\n<p><strong>You<\/strong><\/p>\n<p>You want to work for a services company that is rapidly changing the way the largest construction firms do business. You are motivated by solving problems and partnering with our clients and suppliers. You want to work with great people and enjoy being a part of a strong team. You are a knowledgeable Operator who is not afraid to jump into every detail. You want to be in a place where continuous learning and growth is the norm. You are adaptable and able to juggle multiple initiatives concurrently.<\/p>\n<p><strong>Responsibilities:<\/strong><\/p>\n<ul><li>Operating excavators in a civil construction environment<\/li><li>Performing all pre-shift inspections, some basic maintenance and upkeep<\/li><li>Working with teammates on crew to maximize production while always maintaining our safety rules and regulations.<\/li><\/ul>\n<p><strong>Requirements:<\/strong><\/p>\n<ul><li>Safety oriented, awareness of everyone and everything that is around you<\/li><li>Strong work ethic<\/li><li>Willingness to learn<\/li><li>Ability to be flexible and to adapt<\/li><li>Experience with heavy equipment<\/li><li>Preferred to have OSHA training<\/li><\/ul>","%category%":"Operations","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/0eeb34ce4b7d-excavator-operator","%breezy_id%":"0eeb34ce4b7d","%breezy_friendly_id%":"0eeb34ce4b7d-excavator-operator","%breezy_created_date%":"2025-04-03T18:53:41.068Z","%breezy_updated_date%":"2025-09-22T18:35:57.866Z","%_wpgmp_location_city%":"Scranton","%_wpgmp_location_state%":"PA","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Scranton, PA, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"41.410314","%_wpgmp_metabox_longitude%":"-75.661099","%rank_math_internal_links_processed%":"1"}},"id":2776,"infowindow_disable":false},{"source":"post","title":"Construction Laborer","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Construction Laborer\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Turner Staffing Group \u2013 Construction Laborer Do you love the dirt world? Do you think differently? Are you ready to&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/construction-laborer\/\" name=\"Construction Laborer\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Turner Staffing Group \u2013 Construction Laborer Do you love the dirt world? Do you think differently? Are you ready to&hellip;","address":"Philadelphia, PA, USA","location":{"lat":"39.9525839","city":"Philadelphia","state":"PA","country":"United States","lng":"-75.1652215","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/construction-laborer\/","zoom":19,"extra_fields":{"post_excerpt":"Turner Staffing Group \u2013 Construction Laborer Do you love the dirt world? Do you think differently? Are you ready to&hellip;","post_content":"<p><strong><u>Turner Staffing Group \u2013 Construction Laborer<\/u><\/strong><\/p>\n<p>Do you love the dirt world? Do you think differently? Are you ready to define the future of this industry?<\/p>\n<p>We\u2019ve been waiting for you! Turner Staffing Group is committed to changing the way civil construction companies do business. We develop our people. We partner with our clients. We believe in win, win, win.<\/p>\n<p>We are looking for a dynamic and talented Construction Laborers for our fast-growing, forward thinking client based in the Philadelphia area.<br><\/p>\n<p><strong>You<\/strong><\/p>\n<p>You want to work for a services company that is rapidly changing the way the largest construction firms do business. You are motivated by solving problems and partnering with our clients and suppliers. You want to work with great people and enjoy being a part of a strong team. You are a knowledgeable individual who is not afraid to jump into every detail. You want to be in a place where continuous learning and growth is the norm. You are adaptable and able to juggle multiple initiatives concurrently.<\/p>\n<p><strong>Responsibilities:<\/strong><\/p>\n<ul><li>Performing tasks as directed by management&nbsp;in a civil construction environment<\/li><li>Assist in basic maintenance and upkeep of equipment<\/li><li>Working with teammates on crew to maximize production while always maintaining our safety rules and regulations.<\/li><\/ul>\n<p><strong>Requirements:<\/strong><\/p>\n<ul><li>Safety oriented, awareness of everyone and everything that is around you<\/li><li>Strong work ethic<\/li><li>Willingness to learn<\/li><li>Ability to be flexible and to adapt<\/li><li>Experience with heavy equipment is a plus<\/li><li>Preferred to have OSHA training<\/li><\/ul>","post_title":"Construction Laborer","post_link":"https:\/\/turnerstaffing.com\/position\/construction-laborer\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Associate","%location_country%":"United States","%location_city%":"Philadelphia","%location_state_id%":"PA","%location_state_name%":"Pennsylvania","%location_city_state%":"Philadelphia, PA","%education%":"Unspecified","%department%":"","%description%":"<p><strong><u>Turner Staffing Group \u2013 Construction Laborer<\/u><\/strong><\/p>\n<p>Do you love the dirt world? Do you think differently? Are you ready to define the future of this industry?<\/p>\n<p>We\u2019ve been waiting for you! Turner Staffing Group is committed to changing the way civil construction companies do business. We develop our people. We partner with our clients. We believe in win, win, win.<\/p>\n<p>We are looking for a dynamic and talented Construction Laborers for our fast-growing, forward thinking client based in the Philadelphia area.<br><\/p>\n<p><strong>You<\/strong><\/p>\n<p>You want to work for a services company that is rapidly changing the way the largest construction firms do business. You are motivated by solving problems and partnering with our clients and suppliers. You want to work with great people and enjoy being a part of a strong team. You are a knowledgeable individual who is not afraid to jump into every detail. You want to be in a place where continuous learning and growth is the norm. You are adaptable and able to juggle multiple initiatives concurrently.<\/p>\n<p><strong>Responsibilities:<\/strong><\/p>\n<ul><li>Performing tasks as directed by management&nbsp;in a civil construction environment<\/li><li>Assist in basic maintenance and upkeep of equipment<\/li><li>Working with teammates on crew to maximize production while always maintaining our safety rules and regulations.<\/li><\/ul>\n<p><strong>Requirements:<\/strong><\/p>\n<ul><li>Safety oriented, awareness of everyone and everything that is around you<\/li><li>Strong work ethic<\/li><li>Willingness to learn<\/li><li>Ability to be flexible and to adapt<\/li><li>Experience with heavy equipment is a plus<\/li><li>Preferred to have OSHA training<\/li><\/ul>","%category%":"Operations","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/27b18bea9dd8-construction-laborer","%breezy_id%":"27b18bea9dd8","%breezy_friendly_id%":"27b18bea9dd8-construction-laborer","%breezy_created_date%":"2025-04-03T18:00:18.513Z","%breezy_updated_date%":"2025-09-22T17:09:05.848Z","%_wpgmp_location_city%":"Philadelphia","%_wpgmp_location_state%":"PA","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Philadelphia, PA, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"39.9525839","%_wpgmp_metabox_longitude%":"-75.1652215","%rank_math_internal_links_processed%":"1"}},"id":2773,"infowindow_disable":false},{"source":"post","title":"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    About Us:&nbsp;Turner Staffing Group is proud to partner with a leading mining company in Pottsville, Pennsylvania, dedicated to responsible and&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/haul-truck-operator-mining-2\/\" name=\"Haul Truck Operator &#8211; Mining\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"About Us:&nbsp;Turner Staffing Group is proud to partner with a leading mining company in Pottsville, Pennsylvania, dedicated to responsible and&hellip;","address":"Pottsville, PA, USA","location":{"lat":"40.6877265","city":"Pottsville","state":"PA","country":"United States","lng":"-76.1970575","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/haul-truck-operator-mining-2\/","zoom":19,"extra_fields":{"post_excerpt":"About Us:&nbsp;Turner Staffing Group is proud to partner with a leading mining company in Pottsville, Pennsylvania, dedicated to responsible and&hellip;","post_content":"<p><strong>About Us:<\/strong>&nbsp;Turner Staffing Group is proud to partner with a leading mining company in Pottsville, Pennsylvania, 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-2\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"","%location_country%":"United States","%location_city%":"Pottsville","%location_state_id%":"PA","%location_state_name%":"Pennsylvania","%location_city_state%":"Pottsville, PA","%education%":"","%department%":"","%description%":"<p><strong>About Us:<\/strong>&nbsp;Turner Staffing Group is proud to partner with a leading mining company in Pottsville, Pennsylvania, 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%":"","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/d0bec1f0eacd-haul-truck-operator-mining","%breezy_id%":"d0bec1f0eacd","%breezy_friendly_id%":"d0bec1f0eacd-haul-truck-operator-mining","%breezy_created_date%":"2024-11-11T21:36:31.850Z","%breezy_updated_date%":"2025-09-22T17:12:08.324Z","%_wpgmp_location_city%":"Pottsville","%_wpgmp_location_state%":"PA","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Pottsville, PA, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"40.6877265","%_wpgmp_metabox_longitude%":"-76.1970575","%rank_math_internal_links_processed%":"1"}},"id":2772,"infowindow_disable":false},{"source":"post","title":"Sr. Infrastructure Systems Engineer","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Sr. Infrastructure Systems Engineer\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Sr. Infrastructure Systems Engineer Job Description: Turner Staffing Group is partnered with a mining company in Arizona that is looking&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/sr-infrastructure-systems-engineer\/\" name=\"Sr. Infrastructure Systems Engineer\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Sr. Infrastructure Systems Engineer Job Description: Turner Staffing Group is partnered with a mining company in Arizona that is looking&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\/sr-infrastructure-systems-engineer\/","zoom":19,"extra_fields":{"post_excerpt":"Sr. Infrastructure Systems Engineer Job Description: Turner Staffing Group is partnered with a mining company in Arizona that is looking&hellip;","post_content":"<h1>Sr. Infrastructure Systems Engineer<\/h1>\n<p><strong>Job Description:<\/strong><br>\nTurner Staffing Group is partnered with a mining company in Arizona that is looking for a <strong>Sr. Infrastructure Systems Engineer<\/strong> to maintain, optimize, and ensure the availability of the company\u2019s IT infrastructure. This includes servers, storage systems, and cloud services. The Sr. Infrastructure Systems Engineer will work under the guidance of the IT Manager to support business operations by ensuring reliable and secure infrastructure.<\/p>\n<p><strong>Roles and Responsibilities:<\/strong><\/p>\n<ul>\n<li>\n<p><strong>Infrastructure Management:<\/strong> Maintain\/manage physical &amp; virtual servers, oversee storage systems, and implement\/manage cloud services.<\/p>\n<\/li>\n<li>\n<p><strong>System Monitoring &amp; Maintenance:<\/strong> Monitor performance, implement improvements, and perform system updates\/patches.<\/p>\n<\/li>\n<li>\n<p><strong>Security Management:<\/strong> Implement security measures, conduct audits, and perform vulnerability assessments.<\/p>\n<\/li>\n<li>\n<p><strong>Disaster Recovery:<\/strong> Develop\/maintain disaster recovery plans and ensure backups\/recovery processes are tested.<\/p>\n<\/li>\n<li>\n<p><strong>Support &amp; Troubleshooting:<\/strong> Provide second-level support and resolve complex infrastructure issues.<\/p>\n<\/li>\n<li>\n<p><strong>Documentation:<\/strong> Maintain accurate infrastructure documentation.<\/p>\n<\/li>\n<\/ul>\n<p><strong>Required Skills:<\/strong><\/p>\n<ul>\n<li>\n<p>Strong understanding of server &amp; storage systems.<\/p>\n<\/li>\n<li>\n<p>Experience with cloud services (AWS, Azure).<\/p>\n<\/li>\n<li>\n<p>Proficiency in virtualization (VMware, Hyper-V).<\/p>\n<\/li>\n<li>\n<p>Familiarity with infrastructure monitoring &amp; management tools.<\/p>\n<\/li>\n<li>\n<p>Knowledge of network protocols\/services.<\/p>\n<\/li>\n<li>\n<p>Problem-solving &amp; troubleshooting expertise.<\/p>\n<\/li>\n<li>\n<p>Experience with security best practices &amp; compliance frameworks (ISO 27001, NIST, GDPR).<\/p>\n<\/li>\n<li>\n<p>Strong documentation &amp; communication skills.<\/p>\n<\/li>\n<\/ul>\n<p><strong>Education &amp; Certifications:<\/strong><\/p>\n<ul>\n<li>\n<p>Bachelor\u2019s in Computer Science, IT, or related field.<\/p>\n<\/li>\n<li>\n<p>Preferred certifications: Microsoft Azure Administrator Associate, VMware Certified Professional, CompTIA Server+.<\/p>\n<\/li>\n<\/ul>\n<p><strong>Experience:<\/strong><\/p>\n<ul>\n<li>\n<p>5\u20137 years in IT infrastructure management.<\/p>\n<\/li>\n<li>\n<p>Proven experience with servers, storage, cloud services, and virtualization.<\/p>\n<\/li>\n<li>\n<p>Strong background in IT security measures.<\/p><\/li><\/ul>","post_title":"Sr. Infrastructure Systems Engineer","post_link":"https:\/\/turnerstaffing.com\/position\/sr-infrastructure-systems-engineer\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Associate","%location_country%":"United States","%location_city%":"Tucson","%location_state_id%":"AZ","%location_state_name%":"Arizona","%location_city_state%":"Tucson, AZ","%education%":"Bachelor's Degree","%department%":"Engineering","%description%":"<h1>Sr. Infrastructure Systems Engineer<\/h1>\n<p><strong>Job Description:<\/strong><br>\nTurner Staffing Group is partnered with a mining company in Arizona that is looking for a <strong>Sr. Infrastructure Systems Engineer<\/strong> to maintain, optimize, and ensure the availability of the company\u2019s IT infrastructure. This includes servers, storage systems, and cloud services. The Sr. Infrastructure Systems Engineer will work under the guidance of the IT Manager to support business operations by ensuring reliable and secure infrastructure.<\/p>\n<p><strong>Roles and Responsibilities:<\/strong><\/p>\n<ul>\n<li>\n<p><strong>Infrastructure Management:<\/strong> Maintain\/manage physical &amp; virtual servers, oversee storage systems, and implement\/manage cloud services.<\/p>\n<\/li>\n<li>\n<p><strong>System Monitoring &amp; Maintenance:<\/strong> Monitor performance, implement improvements, and perform system updates\/patches.<\/p>\n<\/li>\n<li>\n<p><strong>Security Management:<\/strong> Implement security measures, conduct audits, and perform vulnerability assessments.<\/p>\n<\/li>\n<li>\n<p><strong>Disaster Recovery:<\/strong> Develop\/maintain disaster recovery plans and ensure backups\/recovery processes are tested.<\/p>\n<\/li>\n<li>\n<p><strong>Support &amp; Troubleshooting:<\/strong> Provide second-level support and resolve complex infrastructure issues.<\/p>\n<\/li>\n<li>\n<p><strong>Documentation:<\/strong> Maintain accurate infrastructure documentation.<\/p>\n<\/li>\n<\/ul>\n<p><strong>Required Skills:<\/strong><\/p>\n<ul>\n<li>\n<p>Strong understanding of server &amp; storage systems.<\/p>\n<\/li>\n<li>\n<p>Experience with cloud services (AWS, Azure).<\/p>\n<\/li>\n<li>\n<p>Proficiency in virtualization (VMware, Hyper-V).<\/p>\n<\/li>\n<li>\n<p>Familiarity with infrastructure monitoring &amp; management tools.<\/p>\n<\/li>\n<li>\n<p>Knowledge of network protocols\/services.<\/p>\n<\/li>\n<li>\n<p>Problem-solving &amp; troubleshooting expertise.<\/p>\n<\/li>\n<li>\n<p>Experience with security best practices &amp; compliance frameworks (ISO 27001, NIST, GDPR).<\/p>\n<\/li>\n<li>\n<p>Strong documentation &amp; communication skills.<\/p>\n<\/li>\n<\/ul>\n<p><strong>Education &amp; Certifications:<\/strong><\/p>\n<ul>\n<li>\n<p>Bachelor\u2019s in Computer Science, IT, or related field.<\/p>\n<\/li>\n<li>\n<p>Preferred certifications: Microsoft Azure Administrator Associate, VMware Certified Professional, CompTIA Server+.<\/p>\n<\/li>\n<\/ul>\n<p><strong>Experience:<\/strong><\/p>\n<ul>\n<li>\n<p>5\u20137 years in IT infrastructure management.<\/p>\n<\/li>\n<li>\n<p>Proven experience with servers, storage, cloud services, and virtualization.<\/p>\n<\/li>\n<li>\n<p>Strong background in IT security measures.<\/p><\/li><\/ul>","%category%":"Software Development","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/8dc6959e6b77-sr-infrastructure-systems-engineer","%breezy_id%":"8dc6959e6b77","%breezy_friendly_id%":"8dc6959e6b77-sr-infrastructure-systems-engineer","%breezy_created_date%":"2025-09-18T15:20:56.835Z","%breezy_updated_date%":"2025-09-18T15:21:43.807Z","%_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":2771,"infowindow_disable":false},{"source":"post","title":"IT\/OT Infrastructure Manager","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    IT\/OT Infrastructure Manager\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    IT\/OT Infrastructure Manager Job Description: Turner Staffing Group is partnered with a mining company in Arizona that is looking for&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/it-ot-infrastructure-manager\/\" name=\"IT\/OT Infrastructure Manager\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"IT\/OT Infrastructure Manager Job Description: Turner Staffing Group is partnered with a mining company in Arizona that is looking for&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\/it-ot-infrastructure-manager\/","zoom":19,"extra_fields":{"post_excerpt":"IT\/OT Infrastructure Manager Job Description: Turner Staffing Group is partnered with a mining company in Arizona that is looking for&hellip;","post_content":"<h1>IT\/OT Infrastructure Manager<\/h1>\n<p><strong>Job Description:<\/strong><br>\nTurner Staffing Group is partnered with a mining company in Arizona that is looking for an <strong>IT\/OT Infrastructure Manager<\/strong> to oversee enterprise-wide infrastructure including servers, storage systems, data centers, virtualization platforms, backups, and cybersecurity across both Information Technology (IT) and Operational Technology (OT) environments. This role ensures the security, reliability, availability, and performance of the company\u2019s infrastructure systems, directly supporting operational continuity and strategic technology initiatives. The IT\/OT Infrastructure Manager will report directly to the Technology Director.<\/p><h3><strong><u>Roles and Responsibilities<\/u><\/strong><\/h3>\n<p><strong>Server and Systems Administration:<\/strong><\/p>\n<ul>\n<li>\n<p>Manage and maintain server infrastructure including Windows Server (Active Directory, DNS, DHCP, IIS, FSMO), Linux servers, VMware virtualization (vSphere, ESXi), and SAN\/NAS storage arrays.<\/p>\n<\/li>\n<li>\n<p>Perform regular system updates, security patches, upgrades, and lifecycle management.<\/p>\n<\/li>\n<li>\n<p>Ensure optimal system performance through proactive monitoring, tuning, and troubleshooting of IT and OT server infrastructure.<\/p>\n<\/li>\n<\/ul>\n<p><strong>Data Center Operations:<\/strong><\/p>\n<ul>\n<li>\n<p>Oversee management of data center environments, including capacity planning, hardware lifecycle management, cooling, power, physical security, and preventive maintenance schedules.<\/p>\n<\/li>\n<li>\n<p>Coordinate maintenance and repairs, working closely with internal teams and external service providers.<\/p>\n<\/li>\n<li>\n<p>Implement and enforce standards, policies, and procedures to maintain a reliable and secure data center infrastructure.<\/p>\n<\/li>\n<\/ul>\n<p><strong>Backup and Disaster Recovery:<\/strong><\/p>\n<ul>\n<li>\n<p>Develop, implement, and maintain comprehensive backup and disaster recovery strategies utilizing Veeam and VMware technologies.<\/p>\n<\/li>\n<li>\n<p>Regularly test disaster recovery processes to ensure rapid recovery capabilities and minimize business impact during outages.<\/p>\n<\/li>\n<\/ul>\n<p><strong>Cybersecurity and Compliance:<\/strong><\/p>\n<ul>\n<li>\n<p>Implement and manage robust cybersecurity measures, including firewalls, intrusion detection systems (IDS\/IPS), endpoint protection, and security best practices to protect IT and OT infrastructure.<\/p>\n<\/li>\n<li>\n<p>Ensure infrastructure compliance with regulatory standards and company policies (e.g., NIST, IEC 62443).<\/p>\n<\/li>\n<li>\n<p>Perform routine security audits and vulnerability assessments to proactively mitigate risks.<\/p>\n<\/li>\n<\/ul>\n<p><strong>Project Management:<\/strong><\/p>\n<ul>\n<li>\n<p>Lead infrastructure-related projects, clearly defining project scope, timelines, resources, and budgets.<\/p>\n<\/li>\n<li>\n<p>Collaborate with stakeholders across IT, OT, and business operations to ensure alignment and successful project delivery.<\/p>\n<\/li>\n<\/ul>\n<p><strong>Vendor and Contract Management:<\/strong><\/p>\n<ul>\n<li>\n<p>Manage vendor relationships, licensing agreements, warranties, and support contracts to ensure cost-effective infrastructure management.<\/p>\n<\/li>\n<li>\n<p>Negotiate favorable terms and oversee procurement processes for infrastructure-related equipment, software, and services.<\/p>\n<\/li>\n<\/ul>\n<p><strong>Team Leadership and Collaboration:<\/strong><\/p>\n<ul>\n<li>\n<p>Provide leadership, mentorship, and technical guidance to infrastructure team members.<\/p>\n<\/li>\n<li>\n<p>Collaborate closely with the OT Manager and other IT teams to ensure seamless integration and unified support for all infrastructure-related requirements.<\/p>\n<\/li>\n<\/ul>\n<p><strong>Documentation and Reporting:<\/strong><\/p>\n<ul>\n<li>\n<p>Maintain accurate documentation of infrastructure configurations, standards, operational procedures, and system architecture.<\/p>\n<\/li>\n<li>\n<p>Prepare and deliver regular performance, risk, and status reports to senior management.<\/p>\n<\/li>\n<\/ul>\n<h3>Required Skills and Competencies<\/h3>\n<p><strong>Technical Proficiency:<\/strong><\/p>\n<ul>\n<li>\n<p>Extensive hands-on experience managing enterprise-level Windows Server and Linux environments, VMware virtualization, storage (SAN\/NAS), and backup solutions (Veeam).<\/p>\n<\/li>\n<li>\n<p>Strong knowledge of Active Directory, DNS, DHCP, SCCM, and server patching procedures.<\/p>\n<\/li>\n<li>\n<p>Familiarity with network technologies and infrastructure monitoring tools (SNMP, NetFlow, performance monitoring software).<\/p>\n<\/li>\n<\/ul>\n<p><strong>Cybersecurity Expertise:<\/strong><\/p>\n<ul>\n<li>\n<p>Proven track record implementing cybersecurity frameworks and tools to secure IT and OT infrastructure environments.<\/p>\n<\/li>\n<li>\n<p>Deep understanding of infrastructure security best practices and compliance standards.<\/p>\n<\/li>\n<\/ul>\n<p><strong>Project and Budget Management:<\/strong><\/p>\n<ul>\n<li>\n<p>Strong project management skills, including planning, scheduling, budgeting, and delivering complex infrastructure projects on time and within scope.<\/p>\n<\/li>\n<\/ul>\n<p><strong>Disaster Recovery and Business Continuity:<\/strong><\/p>\n<ul>\n<li>\n<p>Practical experience developing, testing, and implementing DR and business continuity plans leveraging backup and virtualization technologies.<\/p>\n<\/li>\n<\/ul>\n<p><strong>Vendor Relationship Management:<\/strong><\/p>\n<ul>\n<li>\n<p>Demonstrated experience negotiating contracts, managing vendor relations, and overseeing procurement processes for infrastructure technologies.<\/p>\n<\/li>\n<\/ul>\n<p><strong>Analytical and Problem-Solving Skills:<\/strong><\/p>\n<ul>\n<li>\n<p>Ability to proactively identify, analyze, and resolve infrastructure issues efficiently.<\/p>\n<\/li>\n<\/ul>\n<h3><strong><u>Required Abilities<\/u><\/strong><\/h3>\n<ul>\n<li>\n<p>Effectively manage competing priorities and perform under pressure.<\/p>\n<\/li>\n<li>\n<p>Proactive, organized, and capable of independent decision-making.<\/p>\n<\/li>\n<li>\n<p>Customer-oriented approach, dedicated to delivering high-quality infrastructure support.<\/p>\n<\/li>\n<li>\n<p>Committed to continuous learning and staying current with emerging infrastructure technologies and industry best practices.<\/p>\n<\/li>\n<\/ul>\n<h3><strong><u>Education and Experience<\/u><\/strong><\/h3>\n<p><strong>Education:<\/strong><\/p>\n<ul>\n<li>\n<p>Bachelor\u2019s degree in Information Technology, Computer Science, Engineering, or related technical field, or equivalent relevant experience.<\/p>\n<\/li>\n<li>\n<p>Certifications such as VMware VCP, Microsoft MCSE, Cisco CCNP, CISSP, or equivalent are strongly preferred.<\/p>\n<\/li>\n<\/ul>\n<p><strong>Experience:<\/strong><\/p>\n<ul>\n<li>\n<p>Minimum 10 years of progressive IT infrastructure management experience, with substantial hands-on exposure to server infrastructure, VMware virtualization, SAN\/NAS storage, backup solutions, and cybersecurity.<\/p>\n<\/li>\n<li>\n<p>Demonstrated success in managing data center operations, disaster recovery strategies, vendor management, and project delivery.<\/p>\n<\/li>\n<li>\n<p>Previous experience supporting infrastructure within mining or industrial environments is preferred.<\/p><\/li><\/ul>","post_title":"IT\/OT Infrastructure Manager","post_link":"https:\/\/turnerstaffing.com\/position\/it-ot-infrastructure-manager\/","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%":"IT","%description%":"<h1>IT\/OT Infrastructure Manager<\/h1>\n<p><strong>Job Description:<\/strong><br>\nTurner Staffing Group is partnered with a mining company in Arizona that is looking for an <strong>IT\/OT Infrastructure Manager<\/strong> to oversee enterprise-wide infrastructure including servers, storage systems, data centers, virtualization platforms, backups, and cybersecurity across both Information Technology (IT) and Operational Technology (OT) environments. This role ensures the security, reliability, availability, and performance of the company\u2019s infrastructure systems, directly supporting operational continuity and strategic technology initiatives. The IT\/OT Infrastructure Manager will report directly to the Technology Director.<\/p><h3><strong><u>Roles and Responsibilities<\/u><\/strong><\/h3>\n<p><strong>Server and Systems Administration:<\/strong><\/p>\n<ul>\n<li>\n<p>Manage and maintain server infrastructure including Windows Server (Active Directory, DNS, DHCP, IIS, FSMO), Linux servers, VMware virtualization (vSphere, ESXi), and SAN\/NAS storage arrays.<\/p>\n<\/li>\n<li>\n<p>Perform regular system updates, security patches, upgrades, and lifecycle management.<\/p>\n<\/li>\n<li>\n<p>Ensure optimal system performance through proactive monitoring, tuning, and troubleshooting of IT and OT server infrastructure.<\/p>\n<\/li>\n<\/ul>\n<p><strong>Data Center Operations:<\/strong><\/p>\n<ul>\n<li>\n<p>Oversee management of data center environments, including capacity planning, hardware lifecycle management, cooling, power, physical security, and preventive maintenance schedules.<\/p>\n<\/li>\n<li>\n<p>Coordinate maintenance and repairs, working closely with internal teams and external service providers.<\/p>\n<\/li>\n<li>\n<p>Implement and enforce standards, policies, and procedures to maintain a reliable and secure data center infrastructure.<\/p>\n<\/li>\n<\/ul>\n<p><strong>Backup and Disaster Recovery:<\/strong><\/p>\n<ul>\n<li>\n<p>Develop, implement, and maintain comprehensive backup and disaster recovery strategies utilizing Veeam and VMware technologies.<\/p>\n<\/li>\n<li>\n<p>Regularly test disaster recovery processes to ensure rapid recovery capabilities and minimize business impact during outages.<\/p>\n<\/li>\n<\/ul>\n<p><strong>Cybersecurity and Compliance:<\/strong><\/p>\n<ul>\n<li>\n<p>Implement and manage robust cybersecurity measures, including firewalls, intrusion detection systems (IDS\/IPS), endpoint protection, and security best practices to protect IT and OT infrastructure.<\/p>\n<\/li>\n<li>\n<p>Ensure infrastructure compliance with regulatory standards and company policies (e.g., NIST, IEC 62443).<\/p>\n<\/li>\n<li>\n<p>Perform routine security audits and vulnerability assessments to proactively mitigate risks.<\/p>\n<\/li>\n<\/ul>\n<p><strong>Project Management:<\/strong><\/p>\n<ul>\n<li>\n<p>Lead infrastructure-related projects, clearly defining project scope, timelines, resources, and budgets.<\/p>\n<\/li>\n<li>\n<p>Collaborate with stakeholders across IT, OT, and business operations to ensure alignment and successful project delivery.<\/p>\n<\/li>\n<\/ul>\n<p><strong>Vendor and Contract Management:<\/strong><\/p>\n<ul>\n<li>\n<p>Manage vendor relationships, licensing agreements, warranties, and support contracts to ensure cost-effective infrastructure management.<\/p>\n<\/li>\n<li>\n<p>Negotiate favorable terms and oversee procurement processes for infrastructure-related equipment, software, and services.<\/p>\n<\/li>\n<\/ul>\n<p><strong>Team Leadership and Collaboration:<\/strong><\/p>\n<ul>\n<li>\n<p>Provide leadership, mentorship, and technical guidance to infrastructure team members.<\/p>\n<\/li>\n<li>\n<p>Collaborate closely with the OT Manager and other IT teams to ensure seamless integration and unified support for all infrastructure-related requirements.<\/p>\n<\/li>\n<\/ul>\n<p><strong>Documentation and Reporting:<\/strong><\/p>\n<ul>\n<li>\n<p>Maintain accurate documentation of infrastructure configurations, standards, operational procedures, and system architecture.<\/p>\n<\/li>\n<li>\n<p>Prepare and deliver regular performance, risk, and status reports to senior management.<\/p>\n<\/li>\n<\/ul>\n<h3>Required Skills and Competencies<\/h3>\n<p><strong>Technical Proficiency:<\/strong><\/p>\n<ul>\n<li>\n<p>Extensive hands-on experience managing enterprise-level Windows Server and Linux environments, VMware virtualization, storage (SAN\/NAS), and backup solutions (Veeam).<\/p>\n<\/li>\n<li>\n<p>Strong knowledge of Active Directory, DNS, DHCP, SCCM, and server patching procedures.<\/p>\n<\/li>\n<li>\n<p>Familiarity with network technologies and infrastructure monitoring tools (SNMP, NetFlow, performance monitoring software).<\/p>\n<\/li>\n<\/ul>\n<p><strong>Cybersecurity Expertise:<\/strong><\/p>\n<ul>\n<li>\n<p>Proven track record implementing cybersecurity frameworks and tools to secure IT and OT infrastructure environments.<\/p>\n<\/li>\n<li>\n<p>Deep understanding of infrastructure security best practices and compliance standards.<\/p>\n<\/li>\n<\/ul>\n<p><strong>Project and Budget Management:<\/strong><\/p>\n<ul>\n<li>\n<p>Strong project management skills, including planning, scheduling, budgeting, and delivering complex infrastructure projects on time and within scope.<\/p>\n<\/li>\n<\/ul>\n<p><strong>Disaster Recovery and Business Continuity:<\/strong><\/p>\n<ul>\n<li>\n<p>Practical experience developing, testing, and implementing DR and business continuity plans leveraging backup and virtualization technologies.<\/p>\n<\/li>\n<\/ul>\n<p><strong>Vendor Relationship Management:<\/strong><\/p>\n<ul>\n<li>\n<p>Demonstrated experience negotiating contracts, managing vendor relations, and overseeing procurement processes for infrastructure technologies.<\/p>\n<\/li>\n<\/ul>\n<p><strong>Analytical and Problem-Solving Skills:<\/strong><\/p>\n<ul>\n<li>\n<p>Ability to proactively identify, analyze, and resolve infrastructure issues efficiently.<\/p>\n<\/li>\n<\/ul>\n<h3><strong><u>Required Abilities<\/u><\/strong><\/h3>\n<ul>\n<li>\n<p>Effectively manage competing priorities and perform under pressure.<\/p>\n<\/li>\n<li>\n<p>Proactive, organized, and capable of independent decision-making.<\/p>\n<\/li>\n<li>\n<p>Customer-oriented approach, dedicated to delivering high-quality infrastructure support.<\/p>\n<\/li>\n<li>\n<p>Committed to continuous learning and staying current with emerging infrastructure technologies and industry best practices.<\/p>\n<\/li>\n<\/ul>\n<h3><strong><u>Education and Experience<\/u><\/strong><\/h3>\n<p><strong>Education:<\/strong><\/p>\n<ul>\n<li>\n<p>Bachelor\u2019s degree in Information Technology, Computer Science, Engineering, or related technical field, or equivalent relevant experience.<\/p>\n<\/li>\n<li>\n<p>Certifications such as VMware VCP, Microsoft MCSE, Cisco CCNP, CISSP, or equivalent are strongly preferred.<\/p>\n<\/li>\n<\/ul>\n<p><strong>Experience:<\/strong><\/p>\n<ul>\n<li>\n<p>Minimum 10 years of progressive IT infrastructure management experience, with substantial hands-on exposure to server infrastructure, VMware virtualization, SAN\/NAS storage, backup solutions, and cybersecurity.<\/p>\n<\/li>\n<li>\n<p>Demonstrated success in managing data center operations, disaster recovery strategies, vendor management, and project delivery.<\/p>\n<\/li>\n<li>\n<p>Previous experience supporting infrastructure within mining or industrial environments is preferred.<\/p><\/li><\/ul>","%category%":"","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/1e113a5fa9cc-it-ot-infrastructure-manager","%breezy_id%":"1e113a5fa9cc","%breezy_friendly_id%":"1e113a5fa9cc-it-ot-infrastructure-manager","%breezy_created_date%":"2025-09-18T15:12:27.500Z","%breezy_updated_date%":"2025-09-18T15:13:27.019Z","%_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":2770,"infowindow_disable":false},{"source":"post","title":"Working Crushing Foreman","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Working Crushing Foreman\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Turner Staffing Group is partnered with a large mining company in Kershaw, SC that is building&nbsp;out a new crushing crew&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/working-crushing-foreman\/\" name=\"Working Crushing Foreman\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Turner Staffing Group is partnered with a large mining company in Kershaw, SC that is building&nbsp;out a new crushing crew&hellip;","address":"Kershaw, SC, USA","location":{"lat":"34.5518201","city":"Kershaw","state":"SC","country":"United States","lng":"-80.5836836","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/working-crushing-foreman\/","zoom":19,"extra_fields":{"post_excerpt":"Turner Staffing Group is partnered with a large mining company in Kershaw, SC that is building&nbsp;out a new crushing crew&hellip;","post_content":"<p>Turner Staffing Group is partnered with a large mining company in Kershaw, SC that is building&nbsp;out a new crushing crew and looking for a Working Crushing Foreman to lead the team.&nbsp;This role is hands-on \u2014 the successful candidate will not only supervise the crew but also&nbsp;operate equipment, oversee safe and efficient production, and perform basic crusher maintenance&nbsp;as needed.<br><br>Responsibilities:<br>-Lead and manage a crushing crew operating cone crushers.<br>-Operate heavy equipment when necessary to support production.<br>-Monitor crushing operations to ensure efficiency and safety standards are met.<br>-Perform and oversee routine\/basic maintenance on cone crushers.<br>-Train and mentor crew members to ensure safe and productive operations.<br>-Coordinate with site management to meet production goals and deadlines.<br><br>Qualifications:<br>-Proven experience working with cone crushers in a mining or quarry environment.<br>-Prior leadership or supervisory experience leading a production crew.<br>-Ability to operate heavy equipment as needed.<br>-Basic mechanical skills with crushers (troubleshooting and routine maintenance).<br>-Strong commitment to safety and team development.<br><br>Why Join:<br>-Opportunity to build and lead a new crushing crew.<br>-Competitive pay and benefits.<br>-Work with a respected mining company on a growing project<\/p>","post_title":"Working Crushing Foreman","post_link":"https:\/\/turnerstaffing.com\/position\/working-crushing-foreman\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"","%location_country%":"United States","%location_city%":"Kershaw","%location_state_id%":"SC","%location_state_name%":"South Carolina","%location_city_state%":"Kershaw, SC","%education%":"","%department%":"","%description%":"<p>Turner Staffing Group is partnered with a large mining company in Kershaw, SC that is building&nbsp;out a new crushing crew and looking for a Working Crushing Foreman to lead the team.&nbsp;This role is hands-on \u2014 the successful candidate will not only supervise the crew but also&nbsp;operate equipment, oversee safe and efficient production, and perform basic crusher maintenance&nbsp;as needed.<br><br>Responsibilities:<br>-Lead and manage a crushing crew operating cone crushers.<br>-Operate heavy equipment when necessary to support production.<br>-Monitor crushing operations to ensure efficiency and safety standards are met.<br>-Perform and oversee routine\/basic maintenance on cone crushers.<br>-Train and mentor crew members to ensure safe and productive operations.<br>-Coordinate with site management to meet production goals and deadlines.<br><br>Qualifications:<br>-Proven experience working with cone crushers in a mining or quarry environment.<br>-Prior leadership or supervisory experience leading a production crew.<br>-Ability to operate heavy equipment as needed.<br>-Basic mechanical skills with crushers (troubleshooting and routine maintenance).<br>-Strong commitment to safety and team development.<br><br>Why Join:<br>-Opportunity to build and lead a new crushing crew.<br>-Competitive pay and benefits.<br>-Work with a respected mining company on a growing project<\/p>","%category%":"","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/1e96727536b9-working-crushing-foreman","%breezy_id%":"1e96727536b9","%breezy_friendly_id%":"1e96727536b9-working-crushing-foreman","%breezy_created_date%":"2025-09-17T16:24:32.839Z","%breezy_updated_date%":"2025-09-17T16:26:09.308Z","%_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":2768,"infowindow_disable":false},{"source":"post","title":"Mine Office Administrator","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Mine Office Administrator\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Job Description: Mine Office Administrator Company: Turner Mining Group Location: Soda Springs, Idaho Reports to: General Plant Manager Job Summary:&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/mine-office-administrator\/\" name=\"Mine Office Administrator\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Job Description: Mine Office Administrator Company: Turner Mining Group Location: Soda Springs, Idaho Reports to: General Plant Manager Job Summary:&hellip;","address":"Soda Springs, ID, USA","location":{"lat":"42.6543652","city":"Soda Springs","state":"ID","country":"United States","lng":"-111.6046687","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/mine-office-administrator\/","zoom":19,"extra_fields":{"post_excerpt":"Job Description: Mine Office Administrator Company: Turner Mining Group Location: Soda Springs, Idaho Reports to: General Plant Manager Job Summary:&hellip;","post_content":"<h3><strong>Job Description: Mine Office Administrator<\/strong><\/h3>\n<p><strong>Company:<\/strong> Turner Mining Group\n<br><strong>Location:<\/strong> Soda Springs, Idaho\n<br><strong>Reports to:<\/strong> General Plant Manager<\/p>\n<p><strong>Job Summary:<\/strong><\/p>\n<p>Turner Mining Group is seeking a highly organized and detail-oriented Mine Office Administrator to join our team in Soda Springs, Idaho. The ideal candidate will be a proactive problem-solver with excellent communication skills, responsible for managing all administrative functions of the mine office and ensuring efficient operations. This role is essential for coordinating communication, managing documentation, and providing critical support to plant management and various departments.<\/p>\n<p><strong>Areas of Responsibility:<\/strong><\/p>\n<ul><li>Coordinate and maintain effective office procedures and efficient workflow.<\/li><li>Implement Corporate and plant-specific policies and procedures.<\/li><li>Coordinate and direct incoming and outgoing mail and courier services.<\/li><li>Maintain appropriate records and manage them according to policy.<\/li><li>Periodically archive or purge files according to the Records Retention Policy and Procedure.<\/li><li>Function as the primary contact for customers calling the plant and take orders as required.<\/li><li>Serve as liaison with Corporate Customer Service to provide customers with needed support and processing of orders.<\/li><li>Plan and schedule truck, prepare shipping documents, and maintain records of all products and customer purchase orders.<\/li><li>Work with the Plant Operations Manager and Production &amp; Shipping Supervisors to establish loadout and shipment schedules.<\/li><li>Compile daily, weekly, monthly, and annual reports of shipments and production.<\/li><li>Maintain customer shipment files, including customer profile information.<\/li><li>Coordinate material sample requests to ensure timely receipt by requisitioner.<\/li><li>Prepare and transmit invoices to Finance.<\/li><li>Handle inquiries from vendors and contractors regarding accounts payable.<\/li><li>Select and\/or make recommendations for purchase of office supplies and equipment.<\/li><li>And other duties as assigned.<\/li><\/ul>\n<p><u><strong>Benefits<\/strong><\/u><br>Turner Mining Group offers a competitive salary, an excellent work culture, and career advancement opportunities. Our team provides a benefits program which includes Medical, Dental, Vision, Life, and a 401k with company match. We believe in a work-life balance and have established paid time off for major holidays.<\/p>\n<p>At Turner Mining Group, we encourage and celebrate an inclusive environment for all employees and are proud to be an equal opportunity workplace and affirmative action employer.<\/p>","post_title":"Mine Office Administrator","post_link":"https:\/\/turnerstaffing.com\/position\/mine-office-administrator\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Associate","%location_country%":"United States","%location_city%":"Soda Springs","%location_state_id%":"ID","%location_state_name%":"Idaho","%location_city_state%":"Soda Springs, ID","%education%":"Unspecified","%department%":"Administration","%description%":"<h3><strong>Job Description: Mine Office Administrator<\/strong><\/h3>\n<p><strong>Company:<\/strong> Turner Mining Group\n<br><strong>Location:<\/strong> Soda Springs, Idaho\n<br><strong>Reports to:<\/strong> General Plant Manager<\/p>\n<p><strong>Job Summary:<\/strong><\/p>\n<p>Turner Mining Group is seeking a highly organized and detail-oriented Mine Office Administrator to join our team in Soda Springs, Idaho. The ideal candidate will be a proactive problem-solver with excellent communication skills, responsible for managing all administrative functions of the mine office and ensuring efficient operations. This role is essential for coordinating communication, managing documentation, and providing critical support to plant management and various departments.<\/p>\n<p><strong>Areas of Responsibility:<\/strong><\/p>\n<ul><li>Coordinate and maintain effective office procedures and efficient workflow.<\/li><li>Implement Corporate and plant-specific policies and procedures.<\/li><li>Coordinate and direct incoming and outgoing mail and courier services.<\/li><li>Maintain appropriate records and manage them according to policy.<\/li><li>Periodically archive or purge files according to the Records Retention Policy and Procedure.<\/li><li>Function as the primary contact for customers calling the plant and take orders as required.<\/li><li>Serve as liaison with Corporate Customer Service to provide customers with needed support and processing of orders.<\/li><li>Plan and schedule truck, prepare shipping documents, and maintain records of all products and customer purchase orders.<\/li><li>Work with the Plant Operations Manager and Production &amp; Shipping Supervisors to establish loadout and shipment schedules.<\/li><li>Compile daily, weekly, monthly, and annual reports of shipments and production.<\/li><li>Maintain customer shipment files, including customer profile information.<\/li><li>Coordinate material sample requests to ensure timely receipt by requisitioner.<\/li><li>Prepare and transmit invoices to Finance.<\/li><li>Handle inquiries from vendors and contractors regarding accounts payable.<\/li><li>Select and\/or make recommendations for purchase of office supplies and equipment.<\/li><li>And other duties as assigned.<\/li><\/ul>\n<p><u><strong>Benefits<\/strong><\/u><br>Turner Mining Group offers a competitive salary, an excellent work culture, and career advancement opportunities. Our team provides a benefits program which includes Medical, Dental, Vision, Life, and a 401k with company match. We believe in a work-life balance and have established paid time off for major holidays.<\/p>\n<p>At Turner Mining Group, we encourage and celebrate an inclusive environment for all employees and are proud to be an equal opportunity workplace and affirmative action employer.<\/p>","%category%":"Operations","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/0728906c79c9-mine-office-administrator","%breezy_id%":"0728906c79c9","%breezy_friendly_id%":"0728906c79c9-mine-office-administrator","%breezy_created_date%":"2025-09-17T13:18:40.447Z","%breezy_updated_date%":"2025-09-17T13:20:07.986Z","%_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":2766,"infowindow_disable":false},{"source":"post","title":"Blade Operator","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Blade Operator\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Turner Staffing Group \u2013 Heavy Equipment Operator Do you love mining? Do you think differently? Are you ready to define&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/blade-operator\/\" name=\"Blade Operator\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Turner Staffing Group \u2013 Heavy Equipment Operator Do you love mining? Do you think differently? Are you ready to define&hellip;","address":"Bullhead City, AZ, USA","location":{"lat":"35.1359386","city":"Bullhead City","state":"AZ","country":"United States","lng":"-114.5285981","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/blade-operator\/","zoom":19,"extra_fields":{"post_excerpt":"Turner Staffing Group \u2013 Heavy Equipment Operator Do you love mining? Do you think differently? Are you ready to define&hellip;","post_content":"<p><strong><u>Turner Staffing Group \u2013 Heavy Equipment Operator<\/u><\/strong><\/p>\n<p>Do you love mining? Do you think differently? Are you ready to define the future of this industry?<\/p>\n<p>We\u2019ve been waiting for you! Turner Staffing Group is committed to changing the way mining companies do business. We develop our people. We partner with our clients. We believe in win, win, win.<\/p>\n<p>We are looking for a dynamic and talented mining Blade Operator for our fast-growing, forward thinking mining services company at our project in Bullhead City, AZ.<\/p>\n<p>Turner Staffing Group is seeking an energetic mining professionals who can leverage their mining knowledge to expand upon our fast-growing business, creating best practices for equipment operations to ensure profitable operations.<\/p>\n<p><strong>You<\/strong><\/p>\n<p>You want to work for a services company that is rapidly changing the way the largest materials producers do business. You are motivated by solving problems and partnering with our clients and suppliers. You want to work with great people and enjoy being a part of a strong team. You are a knowledgeable Operator who is not afraid to jump into every detail. You want to be in a place where continuous learning and growth is the norm. You are adaptable and able to juggle multiple initiatives concurrently.<\/p>\n<p><strong>Responsibilities:<\/strong><\/p>\n<ul><li>Operating heavy equipment including loaders, scrapers, blade, excavators, dozers, haul trucks, and other pieces of heavy equipment in a production environment<\/li><li>Performing all pre-shift inspections, some basic maintenance and upkeep<\/li><li>Working with teammates on crew to maximize production while always maintaining our safety rules and regulations.<\/li><\/ul>\n<p><strong>Requirements:<\/strong><\/p>\n<ul><li>Safety oriented, awareness of everyone and everything that is around you<\/li><li>Strong work ethic<\/li><li>Willingness to learn<\/li><li>Ability to be flexible and to adapt<\/li><li>Experience with heavy equipment<\/li><li>Preferred to have MSHA training<\/li><\/ul>","post_title":"Blade Operator","post_link":"https:\/\/turnerstaffing.com\/position\/blade-operator\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Associate","%location_country%":"United States","%location_city%":"Bullhead City","%location_state_id%":"AZ","%location_state_name%":"Arizona","%location_city_state%":"Bullhead City, AZ","%education%":"Unspecified","%department%":"Operations","%description%":"<p><strong><u>Turner Staffing Group \u2013 Heavy Equipment Operator<\/u><\/strong><\/p>\n<p>Do you love mining? Do you think differently? Are you ready to define the future of this industry?<\/p>\n<p>We\u2019ve been waiting for you! Turner Staffing Group is committed to changing the way mining companies do business. We develop our people. We partner with our clients. We believe in win, win, win.<\/p>\n<p>We are looking for a dynamic and talented mining Blade Operator for our fast-growing, forward thinking mining services company at our project in Bullhead City, AZ.<\/p>\n<p>Turner Staffing Group is seeking an energetic mining professionals who can leverage their mining knowledge to expand upon our fast-growing business, creating best practices for equipment operations to ensure profitable operations.<\/p>\n<p><strong>You<\/strong><\/p>\n<p>You want to work for a services company that is rapidly changing the way the largest materials producers do business. You are motivated by solving problems and partnering with our clients and suppliers. You want to work with great people and enjoy being a part of a strong team. You are a knowledgeable Operator who is not afraid to jump into every detail. You want to be in a place where continuous learning and growth is the norm. You are adaptable and able to juggle multiple initiatives concurrently.<\/p>\n<p><strong>Responsibilities:<\/strong><\/p>\n<ul><li>Operating heavy equipment including loaders, scrapers, blade, excavators, dozers, haul trucks, and other pieces of heavy equipment in a production environment<\/li><li>Performing all pre-shift inspections, some basic maintenance and upkeep<\/li><li>Working with teammates on crew to maximize production while always maintaining our safety rules and regulations.<\/li><\/ul>\n<p><strong>Requirements:<\/strong><\/p>\n<ul><li>Safety oriented, awareness of everyone and everything that is around you<\/li><li>Strong work ethic<\/li><li>Willingness to learn<\/li><li>Ability to be flexible and to adapt<\/li><li>Experience with heavy equipment<\/li><li>Preferred to have MSHA training<\/li><\/ul>","%category%":"Operations","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/f35c13e4b30b-blade-operator","%breezy_id%":"f35c13e4b30b","%breezy_friendly_id%":"f35c13e4b30b-blade-operator","%breezy_created_date%":"2025-09-17T15:09:32.324Z","%breezy_updated_date%":"2025-09-17T15:12:24.291Z","%_wpgmp_location_city%":"Bullhead City","%_wpgmp_location_state%":"AZ","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Bullhead City, AZ, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"35.1359386","%_wpgmp_metabox_longitude%":"-114.5285981","%rank_math_internal_links_processed%":"1"}},"id":2767,"infowindow_disable":false},{"source":"post","title":"Dozer Operator","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Dozer Operator\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Turner Staffing Group \u2013 Dozer Operator Do you love the dirt world? Do you think differently? Are you ready to&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/dozer-operator-6\/\" name=\"Dozer Operator\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Turner Staffing Group \u2013 Dozer Operator Do you love the dirt world? Do you think differently? Are you ready to&hellip;","address":"Philadelphia, PA, USA","location":{"lat":"39.9525839","city":"Philadelphia","state":"PA","country":"United States","lng":"-75.1652215","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/dozer-operator-6\/","zoom":19,"extra_fields":{"post_excerpt":"Turner Staffing Group \u2013 Dozer Operator Do you love the dirt world? Do you think differently? Are you ready to&hellip;","post_content":"<p><strong><u>Turner Staffing Group \u2013 Dozer Operator<\/u><\/strong><\/p>\n<p>Do you love the dirt world? Do you think differently? Are you ready to define the future of this industry?<\/p>\n<p>We\u2019ve been waiting for you! Turner Staffing Group is committed to changing the way civil construction&nbsp;companies do business. We develop our people. We partner with our clients. We believe in win, win, win.<\/p>\n<p>We are looking for a dynamic and talented Dozer Operators for our fast-growing, forward thinking client based&nbsp;in the Philadelphia area.<br><\/p>\n<p><strong>You<\/strong><\/p>\n<p>You want to work for a services company that is rapidly changing the way the largest construction firms&nbsp;do business. You are motivated by solving problems and partnering with our clients and suppliers. You want to work with great people and enjoy being a part of a strong team. You are a knowledgeable Operator who is not afraid to jump into every detail. You want to be in a place where continuous learning and growth is the norm. You are adaptable and able to juggle multiple initiatives concurrently.<\/p>\n<p><strong>Responsibilities:<\/strong><\/p>\n<ul><li>Operating excavators in a civil construction&nbsp;environment<\/li><li>Performing all pre-shift inspections, some basic maintenance and upkeep<\/li><li>Working with teammates on crew to maximize production while always maintaining our safety rules and regulations.<\/li><\/ul>\n<p><strong>Requirements:<\/strong><\/p>\n<ul><li>Safety oriented, awareness of everyone and everything that is around you<\/li><li>Strong work ethic<\/li><li>Willingness to learn<\/li><li>Ability to be flexible and to adapt<\/li><li>Experience with heavy equipment<\/li><li>Preferred to have OSHA training<\/li><\/ul>","post_title":"Dozer Operator","post_link":"https:\/\/turnerstaffing.com\/position\/dozer-operator-6\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Mid Level","%location_country%":"United States","%location_city%":"Philadelphia","%location_state_id%":"PA","%location_state_name%":"Pennsylvania","%location_city_state%":"Philadelphia, PA","%education%":"Unspecified","%department%":"","%description%":"<p><strong><u>Turner Staffing Group \u2013 Dozer Operator<\/u><\/strong><\/p>\n<p>Do you love the dirt world? Do you think differently? Are you ready to define the future of this industry?<\/p>\n<p>We\u2019ve been waiting for you! Turner Staffing Group is committed to changing the way civil construction&nbsp;companies do business. We develop our people. We partner with our clients. We believe in win, win, win.<\/p>\n<p>We are looking for a dynamic and talented Dozer Operators for our fast-growing, forward thinking client based&nbsp;in the Philadelphia area.<br><\/p>\n<p><strong>You<\/strong><\/p>\n<p>You want to work for a services company that is rapidly changing the way the largest construction firms&nbsp;do business. You are motivated by solving problems and partnering with our clients and suppliers. You want to work with great people and enjoy being a part of a strong team. You are a knowledgeable Operator who is not afraid to jump into every detail. You want to be in a place where continuous learning and growth is the norm. You are adaptable and able to juggle multiple initiatives concurrently.<\/p>\n<p><strong>Responsibilities:<\/strong><\/p>\n<ul><li>Operating excavators in a civil construction&nbsp;environment<\/li><li>Performing all pre-shift inspections, some basic maintenance and upkeep<\/li><li>Working with teammates on crew to maximize production while always maintaining our safety rules and regulations.<\/li><\/ul>\n<p><strong>Requirements:<\/strong><\/p>\n<ul><li>Safety oriented, awareness of everyone and everything that is around you<\/li><li>Strong work ethic<\/li><li>Willingness to learn<\/li><li>Ability to be flexible and to adapt<\/li><li>Experience with heavy equipment<\/li><li>Preferred to have OSHA training<\/li><\/ul>","%category%":"Operations","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/6daac192b598-dozer-operator","%breezy_id%":"6daac192b598","%breezy_friendly_id%":"6daac192b598-dozer-operator","%breezy_created_date%":"2025-04-03T16:25:53.355Z","%breezy_updated_date%":"2025-09-17T14:37:13.983Z","%_wpgmp_location_city%":"Philadelphia","%_wpgmp_location_state%":"PA","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Philadelphia, PA, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"39.9525839","%_wpgmp_metabox_longitude%":"-75.1652215","%rank_math_internal_links_processed%":"1"}},"id":2764,"infowindow_disable":false},{"source":"post","title":"Haul Truck Driver","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Haul Truck Driver\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Turner Staffing Group \u2013 Haul Truck Driver Do you love the dirt world? Do you think differently? Are you ready&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/haul-truck-driver-5\/\" name=\"Haul Truck Driver\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Turner Staffing Group \u2013 Haul Truck Driver Do you love the dirt world? Do you think differently? Are you ready&hellip;","address":"Bowmansville, PA, USA","location":{"lat":"40.1967609","city":"Bowmansville","state":"PA","country":"United States","lng":"-76.0174416","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/haul-truck-driver-5\/","zoom":19,"extra_fields":{"post_excerpt":"Turner Staffing Group \u2013 Haul Truck Driver Do you love the dirt world? Do you think differently? Are you ready&hellip;","post_content":"<p><strong><u>Turner Staffing Group \u2013 Haul Truck Driver<\/u><\/strong><\/p>\n<p>Do you love the dirt world? Do you think differently? Are you ready to define the future of this industry?<\/p>\n<p>We\u2019ve been waiting for you! Turner Staffing Group is committed to changing the way civil construction companies do business. We develop our people. We partner with our clients. We believe in win, win, win.<\/p>\n<p>We are looking for a dynamic and talented Haul Truck Drivers for our fast-growing, forward thinking client based in the Philadelphia area.<br><\/p>\n<p><strong>You<\/strong><\/p>\n<p>You want to work for a services company that is rapidly changing the way the largest construction firms do business. You are motivated by solving problems and partnering with our clients and suppliers. You want to work with great people and enjoy being a part of a strong team. You are a knowledgeable Operator who is not afraid to jump into every detail. You want to be in a place where continuous learning and growth is the norm. You are adaptable and able to juggle multiple initiatives concurrently.<\/p>\n<p><strong>Responsibilities:<\/strong><\/p>\n<ul><li>Operating haul trucks in a civil construction environment<\/li><li>Performing all pre-shift inspections, some basic maintenance and upkeep<\/li><li>Working with teammates on crew to maximize production while always maintaining our safety rules and regulations.<\/li><\/ul>\n<p><strong>Requirements:<\/strong><\/p>\n<ul><li>Safety oriented, awareness of everyone and everything that is around you<\/li><li>Strong work ethic<\/li><li>Willingness to learn<\/li><li>Ability to be flexible and to adapt<\/li><li>Experience with heavy equipment<\/li><li>Preferred to have OSHA training<\/li><\/ul>","post_title":"Haul Truck Driver","post_link":"https:\/\/turnerstaffing.com\/position\/haul-truck-driver-5\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Associate","%location_country%":"United States","%location_city%":"Bowmansville","%location_state_id%":"PA","%location_state_name%":"Pennsylvania","%location_city_state%":"Bowmansville, PA","%education%":"Unspecified","%department%":"","%description%":"<p><strong><u>Turner Staffing Group \u2013 Haul Truck Driver<\/u><\/strong><\/p>\n<p>Do you love the dirt world? Do you think differently? Are you ready to define the future of this industry?<\/p>\n<p>We\u2019ve been waiting for you! Turner Staffing Group is committed to changing the way civil construction companies do business. We develop our people. We partner with our clients. We believe in win, win, win.<\/p>\n<p>We are looking for a dynamic and talented Haul Truck Drivers for our fast-growing, forward thinking client based in the Philadelphia area.<br><\/p>\n<p><strong>You<\/strong><\/p>\n<p>You want to work for a services company that is rapidly changing the way the largest construction firms do business. You are motivated by solving problems and partnering with our clients and suppliers. You want to work with great people and enjoy being a part of a strong team. You are a knowledgeable Operator who is not afraid to jump into every detail. You want to be in a place where continuous learning and growth is the norm. You are adaptable and able to juggle multiple initiatives concurrently.<\/p>\n<p><strong>Responsibilities:<\/strong><\/p>\n<ul><li>Operating haul trucks in a civil construction environment<\/li><li>Performing all pre-shift inspections, some basic maintenance and upkeep<\/li><li>Working with teammates on crew to maximize production while always maintaining our safety rules and regulations.<\/li><\/ul>\n<p><strong>Requirements:<\/strong><\/p>\n<ul><li>Safety oriented, awareness of everyone and everything that is around you<\/li><li>Strong work ethic<\/li><li>Willingness to learn<\/li><li>Ability to be flexible and to adapt<\/li><li>Experience with heavy equipment<\/li><li>Preferred to have OSHA training<\/li><\/ul>","%category%":"Operations","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/9dca286535b8-haul-truck-driver","%breezy_id%":"9dca286535b8","%breezy_friendly_id%":"9dca286535b8-haul-truck-driver","%breezy_created_date%":"2025-04-03T17:55:01.519Z","%breezy_updated_date%":"2025-10-20T17:43:10.128Z","%_wpgmp_location_city%":"Bowmansville","%_wpgmp_location_state%":"PA","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Bowmansville, PA, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"40.1967609","%_wpgmp_metabox_longitude%":"-76.0174416","%rank_math_internal_links_processed%":"1"}},"id":2765,"infowindow_disable":false},{"source":"post","title":"Excavator Operator","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Excavator Operator\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Turner Staffing Group \u2013 Excavator Operator Do you love the dirt world? Do you think differently? Are you ready to&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/excavator-operator-5\/\" name=\"Excavator Operator\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Turner Staffing Group \u2013 Excavator Operator Do you love the dirt world? Do you think differently? Are you ready to&hellip;","address":"Philadelphia, PA, USA","location":{"lat":"39.9525839","city":"Philadelphia","state":"PA","country":"United States","lng":"-75.1652215","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/excavator-operator-5\/","zoom":19,"extra_fields":{"post_excerpt":"Turner Staffing Group \u2013 Excavator Operator Do you love the dirt world? Do you think differently? Are you ready to&hellip;","post_content":"<p><strong><u>Turner Staffing Group \u2013 Excavator Operator<\/u><\/strong><\/p>\n<p>Do you love the dirt world? Do you think differently? Are you ready to define the future of this industry?<\/p>\n<p>We\u2019ve been waiting for you! Turner Staffing Group is committed to changing the way civil construction&nbsp;companies do business. We develop our people. We partner with our clients. We believe in win, win, win.<\/p>\n<p>We are looking for a dynamic and talented Excavator Operators for our fast-growing, forward thinking client based in the Philadelphia area.<br><\/p>\n\n<p><strong>You<\/strong><\/p>\n<p>You want to work for a services company that is rapidly changing the way the largest construction firms do business. You are motivated by solving problems and partnering with our clients and suppliers. You want to work with great people and enjoy being a part of a strong team. You are a knowledgeable Operator who is not afraid to jump into every detail. You want to be in a place where continuous learning and growth is the norm. You are adaptable and able to juggle multiple initiatives concurrently.<\/p>\n<p><strong>Responsibilities:<\/strong><\/p>\n<ul><li>Operating excavators in a civil construction environment<\/li><li>Performing all pre-shift inspections, some basic maintenance and upkeep<\/li><li>Working with teammates on crew to maximize production while always maintaining our safety rules and regulations.<\/li><\/ul>\n<p><strong>Requirements:<\/strong><\/p>\n<ul><li>Safety oriented, awareness of everyone and everything that is around you<\/li><li>Strong work ethic<\/li><li>Willingness to learn<\/li><li>Ability to be flexible and to adapt<\/li><li>Experience with heavy equipment<\/li><li>Preferred to have OSHA training<\/li><\/ul>","post_title":"Excavator Operator","post_link":"https:\/\/turnerstaffing.com\/position\/excavator-operator-5\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Mid Level","%location_country%":"United States","%location_city%":"Philadelphia","%location_state_id%":"PA","%location_state_name%":"Pennsylvania","%location_city_state%":"Philadelphia, PA","%education%":"Unspecified","%department%":"","%description%":"<p><strong><u>Turner Staffing Group \u2013 Excavator Operator<\/u><\/strong><\/p>\n<p>Do you love the dirt world? Do you think differently? Are you ready to define the future of this industry?<\/p>\n<p>We\u2019ve been waiting for you! Turner Staffing Group is committed to changing the way civil construction&nbsp;companies do business. We develop our people. We partner with our clients. We believe in win, win, win.<\/p>\n<p>We are looking for a dynamic and talented Excavator Operators for our fast-growing, forward thinking client based in the Philadelphia area.<br><\/p>\n\n<p><strong>You<\/strong><\/p>\n<p>You want to work for a services company that is rapidly changing the way the largest construction firms do business. You are motivated by solving problems and partnering with our clients and suppliers. You want to work with great people and enjoy being a part of a strong team. You are a knowledgeable Operator who is not afraid to jump into every detail. You want to be in a place where continuous learning and growth is the norm. You are adaptable and able to juggle multiple initiatives concurrently.<\/p>\n<p><strong>Responsibilities:<\/strong><\/p>\n<ul><li>Operating excavators in a civil construction environment<\/li><li>Performing all pre-shift inspections, some basic maintenance and upkeep<\/li><li>Working with teammates on crew to maximize production while always maintaining our safety rules and regulations.<\/li><\/ul>\n<p><strong>Requirements:<\/strong><\/p>\n<ul><li>Safety oriented, awareness of everyone and everything that is around you<\/li><li>Strong work ethic<\/li><li>Willingness to learn<\/li><li>Ability to be flexible and to adapt<\/li><li>Experience with heavy equipment<\/li><li>Preferred to have OSHA training<\/li><\/ul>","%category%":"Operations","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/3ad5c75065c7-excavator-operator","%breezy_id%":"3ad5c75065c7","%breezy_friendly_id%":"3ad5c75065c7-excavator-operator","%breezy_created_date%":"2025-04-03T16:23:33.387Z","%breezy_updated_date%":"2025-09-19T17:21:21.270Z","%_wpgmp_location_city%":"Philadelphia","%_wpgmp_location_state%":"PA","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Philadelphia, PA, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"39.9525839","%_wpgmp_metabox_longitude%":"-75.1652215","%rank_math_internal_links_processed%":"1"}},"id":2763,"infowindow_disable":false},{"source":"post","title":"Dozer Operator","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Dozer Operator\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Job Summary: Turner Staffing Group is seeking a skilled and experienced Dozer Operator for a reputable mining company located in&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/dozer-operator-5\/\" name=\"Dozer Operator\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Job Summary: Turner Staffing Group is seeking a skilled and experienced Dozer Operator for a reputable mining company located in&hellip;","address":"Bowmansville, PA, USA","location":{"lat":"40.1967609","city":"Bowmansville","state":"PA","country":"United States","lng":"-76.0174416","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/dozer-operator-5\/","zoom":19,"extra_fields":{"post_excerpt":"Job Summary: Turner Staffing Group is seeking a skilled and experienced Dozer Operator for a reputable mining company located in&hellip;","post_content":"<h3><strong>Job Summary:<\/strong><\/h3>\n<p>Turner Staffing Group is seeking a skilled and experienced <strong>Dozer Operator<\/strong> for a reputable mining company located in Pennsylvania. The Dozer Operator will be responsible for operating heavy dozers and related equipment to support mining operations in a surface mining setting. The ideal candidate will have experience in heavy equipment operation, particularly dozers, and be able to work efficiently in an outdoor, physically demanding environment.<\/p><h3><strong>Key Responsibilities:<\/strong><\/h3>\n<ul><li><strong>Operate Dozers:<\/strong> Safely operate various dozers (D9, D10, D11, or similar) to perform tasks including grading, pushing, leveling, and clearing materials in a surface mining operation.<\/li><li><strong>Material Handling:<\/strong> Transport materials to designated areas, ensuring that the equipment is operated in compliance with project plans and specifications.<\/li><li><strong>Worksite Safety:<\/strong> Follow all safety protocols and company guidelines to ensure a safe working environment for yourself and others. Adhere to OSHA and MSHA regulations.<\/li><li><strong>Equipment Care:<\/strong> Perform routine maintenance checks on dozers and other heavy equipment, including checking fluid levels, tire pressure, and general machine function. Report any mechanical issues or concerns to the equipment maintenance team.<\/li><li><strong>Collaboration:<\/strong> Work closely with other operators, ground crew, and supervisors to ensure smooth operations and efficient progress of mining activities.<\/li><li><strong>Weather and Terrain Adaptability:<\/strong> Able to work in various weather conditions and on rough, uneven terrain typical of surface mining operations.<\/li><li><strong>Documentation:<\/strong> Maintain accurate records of work performed, including daily logs and any issues or maintenance required on equipment.<\/li><\/ul><p><\/p><h3><strong>Qualifications:<\/strong><\/h3>\n<ul><li><strong>Experience:<\/strong> Minimum of 2-3 years operating dozers in a mining, construction, or similar heavy equipment environment.<\/li><li><strong>Skills:<\/strong><ul><li>Proficient in operating dozers and similar heavy machinery in a mining environment.<\/li><li>Ability to perform routine maintenance and troubleshooting of heavy equipment.<\/li><li>Strong knowledge of safety standards and best practices in a mining or construction setting.<\/li><\/ul><\/li><li><strong>Physical Requirements:<\/strong> Ability to perform physically demanding tasks, including operating heavy machinery for extended periods and working in harsh weather conditions.<\/li><\/ul>","post_title":"Dozer Operator","post_link":"https:\/\/turnerstaffing.com\/position\/dozer-operator-5\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"","%location_country%":"United States","%location_city%":"Bowmansville","%location_state_id%":"PA","%location_state_name%":"Pennsylvania","%location_city_state%":"Bowmansville, PA","%education%":"","%department%":"","%description%":"<h3><strong>Job Summary:<\/strong><\/h3>\n<p>Turner Staffing Group is seeking a skilled and experienced <strong>Dozer Operator<\/strong> for a reputable mining company located in Pennsylvania. The Dozer Operator will be responsible for operating heavy dozers and related equipment to support mining operations in a surface mining setting. The ideal candidate will have experience in heavy equipment operation, particularly dozers, and be able to work efficiently in an outdoor, physically demanding environment.<\/p><h3><strong>Key Responsibilities:<\/strong><\/h3>\n<ul><li><strong>Operate Dozers:<\/strong> Safely operate various dozers (D9, D10, D11, or similar) to perform tasks including grading, pushing, leveling, and clearing materials in a surface mining operation.<\/li><li><strong>Material Handling:<\/strong> Transport materials to designated areas, ensuring that the equipment is operated in compliance with project plans and specifications.<\/li><li><strong>Worksite Safety:<\/strong> Follow all safety protocols and company guidelines to ensure a safe working environment for yourself and others. Adhere to OSHA and MSHA regulations.<\/li><li><strong>Equipment Care:<\/strong> Perform routine maintenance checks on dozers and other heavy equipment, including checking fluid levels, tire pressure, and general machine function. Report any mechanical issues or concerns to the equipment maintenance team.<\/li><li><strong>Collaboration:<\/strong> Work closely with other operators, ground crew, and supervisors to ensure smooth operations and efficient progress of mining activities.<\/li><li><strong>Weather and Terrain Adaptability:<\/strong> Able to work in various weather conditions and on rough, uneven terrain typical of surface mining operations.<\/li><li><strong>Documentation:<\/strong> Maintain accurate records of work performed, including daily logs and any issues or maintenance required on equipment.<\/li><\/ul><p><\/p><h3><strong>Qualifications:<\/strong><\/h3>\n<ul><li><strong>Experience:<\/strong> Minimum of 2-3 years operating dozers in a mining, construction, or similar heavy equipment environment.<\/li><li><strong>Skills:<\/strong><ul><li>Proficient in operating dozers and similar heavy machinery in a mining environment.<\/li><li>Ability to perform routine maintenance and troubleshooting of heavy equipment.<\/li><li>Strong knowledge of safety standards and best practices in a mining or construction setting.<\/li><\/ul><\/li><li><strong>Physical Requirements:<\/strong> Ability to perform physically demanding tasks, including operating heavy machinery for extended periods and working in harsh weather conditions.<\/li><\/ul>","%category%":"","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/ed543c58aa22-dozer-operator","%breezy_id%":"ed543c58aa22","%breezy_friendly_id%":"ed543c58aa22-dozer-operator","%breezy_created_date%":"2024-11-11T21:54:27.413Z","%breezy_updated_date%":"2025-09-18T20:51:23.750Z","%_wpgmp_location_city%":"Bowmansville","%_wpgmp_location_state%":"PA","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Bowmansville, PA, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"40.1967609","%_wpgmp_metabox_longitude%":"-76.0174416","%rank_math_internal_links_processed%":"1"}},"id":2762,"infowindow_disable":false},{"source":"post","title":"Excavator Operator","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Excavator Operator\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    About Us:Turner Staffing Group is a leading staffing agency dedicated to connecting skilled professionals with rewarding opportunities. We are proud&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/excavator-operator-4\/\" name=\"Excavator Operator\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"About Us:Turner Staffing Group is a leading staffing agency dedicated to connecting skilled professionals with rewarding opportunities. We are proud&hellip;","address":"Bowmansville, PA, USA","location":{"lat":"40.1967609","city":"Bowmansville","state":"PA","country":"United States","lng":"-76.0174416","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/excavator-operator-4\/","zoom":19,"extra_fields":{"post_excerpt":"About Us:Turner Staffing Group is a leading staffing agency dedicated to connecting skilled professionals with rewarding opportunities. We are proud&hellip;","post_content":"<p><strong>About Us:<\/strong><br>Turner Staffing Group is a leading staffing agency dedicated to connecting skilled professionals with rewarding opportunities. We are proud to partner with a reputable mining company located in Bowmansville, Pennsylvania. Our client is seeking a skilled and experienced Excavator Operator to join their team and contribute to their ongoing success in the mining industry.<\/p>\n<p><strong>Job Description:<\/strong><\/p>\n<p>As an Excavator Operator, you will play a critical role in the efficient operation of our mining operations in Bowmansville, Pennsylvania. Operating heavy equipment with precision and safety, you will be responsible for excavating and moving materials to facilitate mining activities and achieve production targets.<\/p>\n<p><strong>Key Responsibilities:<\/strong><\/p>\n<ol><li><strong>Equipment Operation:<\/strong>&nbsp;Operate hydraulic excavators with precision and efficiency to excavate, load, and transport materials within the mining site. Familiarity with various excavator attachments and equipment configurations is preferred.<\/li><li><strong>Safety Compliance:<\/strong>&nbsp;Adhere to all safety protocols and procedures to ensure a safe working environment for yourself and others. Conduct pre-operation inspections and routine maintenance checks on equipment to identify and address any safety hazards or mechanical issues.<\/li><li><strong>Material Handling:<\/strong>&nbsp;Utilize excavators to move, load, and unload materials such as overburden, ore, and waste rock. Coordinate with other team members to optimize material handling processes and minimize downtime.<\/li><li><strong>Production Support:<\/strong>&nbsp;Support mining operations by excavating trenches, stockpiling materials, and shaping terrain as required. Work collaboratively with supervisors and other operators to achieve production targets and meet project deadlines.<\/li><li><strong>Quality Control:<\/strong>&nbsp;Maintain a high level of accuracy and precision in material handling activities to ensure the quality and integrity of mined materials. Follow established procedures for separating and stockpiling different grades of materials as required.<\/li><li><strong>Equipment Maintenance:<\/strong>&nbsp;Perform routine maintenance tasks on excavators, including greasing, lubricating, and replacing worn parts. Report any mechanical issues or equipment malfunctions to the maintenance team for timely repairs.<\/li><\/ol>\n<p><strong>Qualifications:<\/strong><\/p>\n<ul><li>Previous experience operating hydraulic excavators in a mining or heavy construction environment is required.<\/li><li>Proficiency in operating excavators with precision and accuracy, including the ability to manipulate attachments and control machine functions effectively.<\/li><li>Strong commitment to safety and adherence to safety regulations and best practices.<\/li><li>Mechanical aptitude and the ability to perform routine maintenance tasks on equipment.<\/li><li>Excellent hand-eye coordination, spatial awareness, and depth perception.<\/li><li>Willingness to work outdoors in various weather conditions and physically demanding environments.<\/li><\/ul>","post_title":"Excavator Operator","post_link":"https:\/\/turnerstaffing.com\/position\/excavator-operator-4\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"","%location_country%":"United States","%location_city%":"Bowmansville","%location_state_id%":"PA","%location_state_name%":"Pennsylvania","%location_city_state%":"Bowmansville, PA","%education%":"","%department%":"","%description%":"<p><strong>About Us:<\/strong><br>Turner Staffing Group is a leading staffing agency dedicated to connecting skilled professionals with rewarding opportunities. We are proud to partner with a reputable mining company located in Bowmansville, Pennsylvania. Our client is seeking a skilled and experienced Excavator Operator to join their team and contribute to their ongoing success in the mining industry.<\/p>\n<p><strong>Job Description:<\/strong><\/p>\n<p>As an Excavator Operator, you will play a critical role in the efficient operation of our mining operations in Bowmansville, Pennsylvania. Operating heavy equipment with precision and safety, you will be responsible for excavating and moving materials to facilitate mining activities and achieve production targets.<\/p>\n<p><strong>Key Responsibilities:<\/strong><\/p>\n<ol><li><strong>Equipment Operation:<\/strong>&nbsp;Operate hydraulic excavators with precision and efficiency to excavate, load, and transport materials within the mining site. Familiarity with various excavator attachments and equipment configurations is preferred.<\/li><li><strong>Safety Compliance:<\/strong>&nbsp;Adhere to all safety protocols and procedures to ensure a safe working environment for yourself and others. Conduct pre-operation inspections and routine maintenance checks on equipment to identify and address any safety hazards or mechanical issues.<\/li><li><strong>Material Handling:<\/strong>&nbsp;Utilize excavators to move, load, and unload materials such as overburden, ore, and waste rock. Coordinate with other team members to optimize material handling processes and minimize downtime.<\/li><li><strong>Production Support:<\/strong>&nbsp;Support mining operations by excavating trenches, stockpiling materials, and shaping terrain as required. Work collaboratively with supervisors and other operators to achieve production targets and meet project deadlines.<\/li><li><strong>Quality Control:<\/strong>&nbsp;Maintain a high level of accuracy and precision in material handling activities to ensure the quality and integrity of mined materials. Follow established procedures for separating and stockpiling different grades of materials as required.<\/li><li><strong>Equipment Maintenance:<\/strong>&nbsp;Perform routine maintenance tasks on excavators, including greasing, lubricating, and replacing worn parts. Report any mechanical issues or equipment malfunctions to the maintenance team for timely repairs.<\/li><\/ol>\n<p><strong>Qualifications:<\/strong><\/p>\n<ul><li>Previous experience operating hydraulic excavators in a mining or heavy construction environment is required.<\/li><li>Proficiency in operating excavators with precision and accuracy, including the ability to manipulate attachments and control machine functions effectively.<\/li><li>Strong commitment to safety and adherence to safety regulations and best practices.<\/li><li>Mechanical aptitude and the ability to perform routine maintenance tasks on equipment.<\/li><li>Excellent hand-eye coordination, spatial awareness, and depth perception.<\/li><li>Willingness to work outdoors in various weather conditions and physically demanding environments.<\/li><\/ul>","%category%":"","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/557ad6ff5763-excavator-operator","%breezy_id%":"557ad6ff5763","%breezy_friendly_id%":"557ad6ff5763-excavator-operator","%breezy_created_date%":"2024-11-11T21:22:05.636Z","%breezy_updated_date%":"2025-09-18T15:13:55.740Z","%_wpgmp_location_city%":"Bowmansville","%_wpgmp_location_state%":"PA","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Bowmansville, PA, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"40.1967609","%_wpgmp_metabox_longitude%":"-76.0174416","%rank_math_internal_links_processed%":"1"}},"id":2760,"infowindow_disable":false},{"source":"post","title":"Heavy Equipment Operator","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Heavy Equipment Operator\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    About Us:Turner Staffing Group, in collaboration with our esteemed mining partner in Bowmansville, Pennsylvania, is actively seeking experienced Heavy Equipment&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/heavy-equipment-operator-9\/\" name=\"Heavy Equipment Operator\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"About Us:Turner Staffing Group, in collaboration with our esteemed mining partner in Bowmansville, Pennsylvania, is actively seeking experienced Heavy Equipment&hellip;","address":"Bowmansville, PA, USA","location":{"lat":"40.1967609","city":"Bowmansville","state":"PA","country":"United States","lng":"-76.0174416","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/heavy-equipment-operator-9\/","zoom":19,"extra_fields":{"post_excerpt":"About Us:Turner Staffing Group, in collaboration with our esteemed mining partner in Bowmansville, Pennsylvania, is actively seeking experienced Heavy Equipment&hellip;","post_content":"<p><strong>About Us:<\/strong><br>Turner Staffing Group, in collaboration with our esteemed mining partner in Bowmansville, Pennsylvania, is actively seeking experienced Heavy Equipment Operators to join our dynamic team. As a leading force in the mining industry, we are dedicated to fostering a culture of excellence, safety, and innovation.<\/p>\n<p><strong>Job Overview:<\/strong><br>We are looking for skilled and safety-conscious Heavy Equipment Operators to contribute to the success of our mining operations. The ideal candidates will have hands-on experience operating a variety of heavy equipment, ensuring the efficient and safe extraction of minerals from the site.<\/p>\n<p><strong>Responsibilities:<\/strong><\/p>\n<ol><li><strong>Equipment Operation:<\/strong><ul><li>Safely operate heavy equipment, including but not limited to bulldozers, excavators, loaders, and haul trucks.<\/li><li>Execute tasks such as grading, digging, loading, and transporting materials as per project requirements.<\/li><\/ul><\/li><li><strong>Safety Compliance:<\/strong><ul><li>Adhere to all safety protocols and guidelines to ensure a secure work environment.<\/li><li>Conduct routine equipment inspections and report any issues promptly.<\/li><\/ul><\/li><li><strong>Efficiency and Productivity:<\/strong><ul><li>Work collaboratively with the mining team to optimize workflow and maximize production efficiency.<\/li><li>Meet project deadlines and production targets while maintaining high-quality standards.<\/li><\/ul><\/li><li><strong>Communication:<\/strong><ul><li>Effectively communicate with supervisors, colleagues, and other team members to ensure seamless project coordination.<\/li><li>Report any operational challenges or concerns in a timely manner.<\/li><\/ul><\/li><li><strong>Maintenance Support:<\/strong><ul><li>Collaborate with the maintenance team to facilitate regular equipment maintenance and repairs.<\/li><li>Assist in troubleshooting equipment issues and participate in scheduled maintenance activities.<\/li><\/ul><\/li><\/ol>\n<p><strong>Requirements:<\/strong><\/p>\n<ul><li>Proven experience as a Heavy Equipment Operator in a mining or similar industry.<\/li><li>Familiarity with safety regulations and commitment to safe work practices.<\/li><li>Ability to operate various heavy equipment efficiently and skillfully.<\/li><li>Strong communication and teamwork skills.<\/li><\/ul>\n<p><strong>Education and Certifications:<\/strong><\/p>\n<ul><li>High school diploma or equivalent.<\/li><li>Relevant certifications for heavy equipment operation.<\/li><li>MSHA experience preferred.&nbsp;<\/li><\/ul>\n<p><strong>Benefits:<\/strong><\/p>\n<ul><li>Competitive salary<\/li><li>Health, dental, and vision insurance<\/li><li>Retirement savings plan<\/li><\/ul>","post_title":"Heavy Equipment Operator","post_link":"https:\/\/turnerstaffing.com\/position\/heavy-equipment-operator-9\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"","%location_country%":"United States","%location_city%":"Bowmansville","%location_state_id%":"PA","%location_state_name%":"Pennsylvania","%location_city_state%":"Bowmansville, PA","%education%":"","%department%":"","%description%":"<p><strong>About Us:<\/strong><br>Turner Staffing Group, in collaboration with our esteemed mining partner in Bowmansville, Pennsylvania, is actively seeking experienced Heavy Equipment Operators to join our dynamic team. As a leading force in the mining industry, we are dedicated to fostering a culture of excellence, safety, and innovation.<\/p>\n<p><strong>Job Overview:<\/strong><br>We are looking for skilled and safety-conscious Heavy Equipment Operators to contribute to the success of our mining operations. The ideal candidates will have hands-on experience operating a variety of heavy equipment, ensuring the efficient and safe extraction of minerals from the site.<\/p>\n<p><strong>Responsibilities:<\/strong><\/p>\n<ol><li><strong>Equipment Operation:<\/strong><ul><li>Safely operate heavy equipment, including but not limited to bulldozers, excavators, loaders, and haul trucks.<\/li><li>Execute tasks such as grading, digging, loading, and transporting materials as per project requirements.<\/li><\/ul><\/li><li><strong>Safety Compliance:<\/strong><ul><li>Adhere to all safety protocols and guidelines to ensure a secure work environment.<\/li><li>Conduct routine equipment inspections and report any issues promptly.<\/li><\/ul><\/li><li><strong>Efficiency and Productivity:<\/strong><ul><li>Work collaboratively with the mining team to optimize workflow and maximize production efficiency.<\/li><li>Meet project deadlines and production targets while maintaining high-quality standards.<\/li><\/ul><\/li><li><strong>Communication:<\/strong><ul><li>Effectively communicate with supervisors, colleagues, and other team members to ensure seamless project coordination.<\/li><li>Report any operational challenges or concerns in a timely manner.<\/li><\/ul><\/li><li><strong>Maintenance Support:<\/strong><ul><li>Collaborate with the maintenance team to facilitate regular equipment maintenance and repairs.<\/li><li>Assist in troubleshooting equipment issues and participate in scheduled maintenance activities.<\/li><\/ul><\/li><\/ol>\n<p><strong>Requirements:<\/strong><\/p>\n<ul><li>Proven experience as a Heavy Equipment Operator in a mining or similar industry.<\/li><li>Familiarity with safety regulations and commitment to safe work practices.<\/li><li>Ability to operate various heavy equipment efficiently and skillfully.<\/li><li>Strong communication and teamwork skills.<\/li><\/ul>\n<p><strong>Education and Certifications:<\/strong><\/p>\n<ul><li>High school diploma or equivalent.<\/li><li>Relevant certifications for heavy equipment operation.<\/li><li>MSHA experience preferred.&nbsp;<\/li><\/ul>\n<p><strong>Benefits:<\/strong><\/p>\n<ul><li>Competitive salary<\/li><li>Health, dental, and vision insurance<\/li><li>Retirement savings plan<\/li><\/ul>","%category%":"","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/3cc09490897f-heavy-equipment-operator","%breezy_id%":"3cc09490897f","%breezy_friendly_id%":"3cc09490897f-heavy-equipment-operator","%breezy_created_date%":"2024-11-11T21:32:36.264Z","%breezy_updated_date%":"2025-10-20T17:47:19.856Z","%_wpgmp_location_city%":"Bowmansville","%_wpgmp_location_state%":"PA","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Bowmansville, PA, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"40.1967609","%_wpgmp_metabox_longitude%":"-76.0174416","%rank_math_internal_links_processed%":"1"}},"id":2761,"infowindow_disable":false},{"source":"post","title":"Electrician","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Electrician\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Electrical Maintenance Technician &ndash; Draglines &amp; Electric Shovels Schedule: DuPont Schedule &ndash; 12-hour rotating days\/nights (6:30 AM&ndash;6:30 PM), 7 days&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/electrician-2\/\" name=\"Electrician\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Electrical Maintenance Technician &ndash; Draglines &amp; Electric Shovels Schedule: DuPont Schedule &ndash; 12-hour rotating days\/nights (6:30 AM&ndash;6:30 PM), 7 days&hellip;","address":"Wright, WY, USA","location":{"lat":"43.7518832","city":"Wright","state":"WY","country":"United States","lng":"-105.4913345","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/electrician-2\/","zoom":19,"extra_fields":{"post_excerpt":"Electrical Maintenance Technician &ndash; Draglines &amp; Electric Shovels Schedule: DuPont Schedule &ndash; 12-hour rotating days\/nights (6:30 AM&ndash;6:30 PM), 7 days&hellip;","post_content":"<p><strong>Electrical Maintenance Technician &ndash; Draglines &amp; Electric Shovels<\/strong><\/p><p><strong>Schedule:<\/strong> DuPont Schedule &ndash; 12-hour rotating days\/nights (6:30 AM&ndash;6:30 PM), 7 days on \/ 7 days off<br \/><strong>Employment Type:<\/strong> Full-Time, Temporary with possibility of converting to permanent position after 6 months.<\/p><p>Turner Staffing Group is seeking <strong>Electrical Maintenance Technicians<\/strong> to support operations on draglines and electric shovels at the North Antelope Rochelle Mine near Wright, Wyoming. This role is ideal for professionals with strong DC motor\/generator troubleshooting skills who thrive in heavy-industrial or mining environments.<\/p><strong>Key Responsibilities<\/strong> <ul><li><p>Perform preventive and breakdown maintenance on draglines, electric shovels, and other fixed\/mobile plant equipment in an open-cut mining environment.<\/p><\/li><li><p>Visibly support and champion our client&rsquo;s mission, values, and &ldquo;Safety as a Way of Life&rdquo; culture.<\/p><\/li><li><p>Inspect work areas and equipment for hazards, damage, and defects.<\/p><\/li><li><p>Review drawings or specifications to determine work methods and sequences.<\/p><\/li><li><p>Diagnose faults, breakdowns, and electrical issues.<\/p><\/li><li><p>Estimate time and materials needed, raise material orders, and complete repairs or component changeouts as required.<\/p><\/li><li><p>Clean and maintain tools, equipment, and work areas.<\/p><\/li><li><p>Train or mentor apprentices or other personnel as needed.<\/p><\/li><li><p>Ensure compliance with safety, environmental, and statutory requirements.<\/p><\/li><li><p>Perform other duties as assigned.<\/p><\/li><\/ul><strong>About You<\/strong> <ul><li><p>At least 3 years of electrical maintenance experience in a heavy-industrial setting (mining preferred, but steel\/paper mills are also valuable backgrounds).<\/p><\/li><li><p><strong>Strong DC motor\/generator troubleshooting and repair experience is required.<\/strong><\/p><\/li><li><p><span style=\"color:#000000;font-size:15px;font-family:Arial, Helvetica, sans-serif\">480-600V experience<\/span><\/p><\/li><li><p><span style=\"color:#000000;font-size:15px;font-family:Arial, Helvetica, sans-serif\">PLC experience is highly preferred<\/span><\/p><\/li><li><p>Willingness to obtain <strong>MSHA certification<\/strong> and a <strong>Wyoming Mining Electrical Card<\/strong> during onboarding (if not currently held).<\/p><\/li><li><p>Ability to solve problems independently and troubleshoot issues in pit areas.<\/p><\/li><li><p>Comfortable working in all weather conditions, at varying times of day, including rotating shifts, weekends, and overtime.<\/p><\/li><li><p>High School Diploma or GED required.<\/p><\/li><\/ul><strong>Physical Requirements<\/strong> <ul><li><p>Ability to stand or sit for extended periods (up to 4 hours).<\/p><\/li><li><p>Comfortable climbing stairs, ladders, and equipment; working from elevated positions.<\/p><\/li><li><p>Capable of frequent lifting\/carrying (10&ndash;50 lbs) without mechanical assistance.<\/p><\/li><li><p>Ability to perform repetitive motions, maintain rapid reflexes, and demonstrate good hand-eye coordination.<\/p><\/li><li><p>Must wear required PPE (protective footwear, hearing\/eye protection, etc.) and work in varying light, noise, and weather conditions.<\/p><\/li><\/ul><strong>Work Schedule &amp; Lifestyle<\/strong> <ul><li><p>DuPont schedule: 12-hour rotating shifts, 7 days on \/ 7 days off.<\/p><\/li><li><p>May require work on weekends, holidays, or alternate shifts as business needs demand.<\/p><\/li><\/ul><strong>Requirements<\/strong> <ul><li><p>Must be <strong>authorized to work in the U.S.<\/strong> (no work visa sponsorship available).<\/p><\/li><li><p>Successful candidates must pass pre-employment screenings and meet all safety standards.<\/p><\/li><\/ul><p><strong>Join Turner Staffing Group and make an impact by supporting one of the world&rsquo;s leading surface coal operations. Apply today to bring your electrical expertise to an exciting, high-performing mining environment!<\/strong><\/p>","post_title":"Electrician","post_link":"https:\/\/turnerstaffing.com\/position\/electrician-2\/","post_featured_image":"","post_categories":"","post_tags":"","%location_country%":"United States","%location_city%":"Wright","%location_state_id%":"WY","%location_city_state%":"Wright, WY","%description%":"<p><strong>Electrical Maintenance Technician &ndash; Draglines &amp; Electric Shovels<\/strong><\/p><p><strong>Schedule:<\/strong> DuPont Schedule &ndash; 12-hour rotating days\/nights (6:30 AM&ndash;6:30 PM), 7 days on \/ 7 days off<br \/><strong>Employment Type:<\/strong> Full-Time, Temporary with possibility of converting to permanent position after 6 months.<\/p><p>Turner Staffing Group is seeking <strong>Electrical Maintenance Technicians<\/strong> to support operations on draglines and electric shovels at the North Antelope Rochelle Mine near Wright, Wyoming. This role is ideal for professionals with strong DC motor\/generator troubleshooting skills who thrive in heavy-industrial or mining environments.<\/p><strong>Key Responsibilities<\/strong> <ul><li><p>Perform preventive and breakdown maintenance on draglines, electric shovels, and other fixed\/mobile plant equipment in an open-cut mining environment.<\/p><\/li><li><p>Visibly support and champion our client&rsquo;s mission, values, and &ldquo;Safety as a Way of Life&rdquo; culture.<\/p><\/li><li><p>Inspect work areas and equipment for hazards, damage, and defects.<\/p><\/li><li><p>Review drawings or specifications to determine work methods and sequences.<\/p><\/li><li><p>Diagnose faults, breakdowns, and electrical issues.<\/p><\/li><li><p>Estimate time and materials needed, raise material orders, and complete repairs or component changeouts as required.<\/p><\/li><li><p>Clean and maintain tools, equipment, and work areas.<\/p><\/li><li><p>Train or mentor apprentices or other personnel as needed.<\/p><\/li><li><p>Ensure compliance with safety, environmental, and statutory requirements.<\/p><\/li><li><p>Perform other duties as assigned.<\/p><\/li><\/ul><strong>About You<\/strong> <ul><li><p>At least 3 years of electrical maintenance experience in a heavy-industrial setting (mining preferred, but steel\/paper mills are also valuable backgrounds).<\/p><\/li><li><p><strong>Strong DC motor\/generator troubleshooting and repair experience is required.<\/strong><\/p><\/li><li><p><span style=\"color:#000000;font-size:15px;font-family:Arial, Helvetica, sans-serif;\">480-600V experience<\/span><\/p><\/li><li><p><span style=\"color:#000000;font-size:15px;font-family:Arial, Helvetica, sans-serif;\">PLC experience is highly preferred<\/span><\/p><\/li><li><p>Willingness to obtain <strong>MSHA certification<\/strong> and a <strong>Wyoming Mining Electrical Card<\/strong> during onboarding (if not currently held).<\/p><\/li><li><p>Ability to solve problems independently and troubleshoot issues in pit areas.<\/p><\/li><li><p>Comfortable working in all weather conditions, at varying times of day, including rotating shifts, weekends, and overtime.<\/p><\/li><li><p>High School Diploma or GED required.<\/p><\/li><\/ul><strong>Physical Requirements<\/strong> <ul><li><p>Ability to stand or sit for extended periods (up to 4 hours).<\/p><\/li><li><p>Comfortable climbing stairs, ladders, and equipment; working from elevated positions.<\/p><\/li><li><p>Capable of frequent lifting\/carrying (10&ndash;50 lbs) without mechanical assistance.<\/p><\/li><li><p>Ability to perform repetitive motions, maintain rapid reflexes, and demonstrate good hand-eye coordination.<\/p><\/li><li><p>Must wear required PPE (protective footwear, hearing\/eye protection, etc.) and work in varying light, noise, and weather conditions.<\/p><\/li><\/ul><strong>Work Schedule &amp; Lifestyle<\/strong> <ul><li><p>DuPont schedule: 12-hour rotating shifts, 7 days on \/ 7 days off.<\/p><\/li><li><p>May require work on weekends, holidays, or alternate shifts as business needs demand.<\/p><\/li><\/ul><strong>Requirements<\/strong> <ul><li><p>Must be <strong>authorized to work in the U.S.<\/strong> (no work visa sponsorship available).<\/p><\/li><li><p>Successful candidates must pass pre-employment screenings and meet all safety standards.<\/p><\/li><\/ul><p><strong>Join Turner Staffing Group and make an impact by supporting one of the world&rsquo;s leading surface coal operations. Apply today to bring your electrical expertise to an exciting, high-performing mining environment!<\/strong><\/p>","%application_url%":"https:\/\/jobs.crelate.com\/portal\/turnerstaffinggroup\/job\/rhsh8o43riyojxdrogg9ixa7hw","%crelate_id%":"rhsh8o43riyojxdrogg9ixa7hw","%crelate_created_date%":"2025-09-16T16:10:40.74Z","%crelate_updated_date%":"2025-10-23T10:49:15.36Z","%_wpgmp_location_city%":"Wright","%_wpgmp_location_state%":"WY","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Wright, WY, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"43.7518832","%_wpgmp_metabox_longitude%":"-105.4913345","%rank_math_internal_links_processed%":"1"}},"id":2759,"infowindow_disable":false},{"source":"post","title":"Safety Support Specialist","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Safety Support Specialist\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Safety Support Specialist Reports to: Director of Safety \u2013 Turner Mining Group Job Description: The Safety Support Specialist is responsible&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/safety-support-specialist\/\" name=\"Safety Support Specialist\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Safety Support Specialist Reports to: Director of Safety \u2013 Turner Mining Group Job Description: The Safety Support Specialist is responsible&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\/safety-support-specialist\/","zoom":19,"extra_fields":{"post_excerpt":"Safety Support Specialist Reports to: Director of Safety \u2013 Turner Mining Group Job Description: The Safety Support Specialist is responsible&hellip;","post_content":"<p><strong><u>Safety Support Specialist<\/u><\/strong><\/p>\n<p><strong>Reports to:<\/strong> Director of Safety \u2013 Turner Mining Group<\/p>\n<p><strong>Job Description:<\/strong><\/p>\n<p>The Safety Support Specialist is responsible for assisting with development, implementation, and <\/p>\n<p>oversight of our comprehensive safety program, ensuring compliance with all applicable regulatory <\/p>\n<p>requirements, and fostering a culture of safe operation within the organization. The Safety Support <\/p>\n<p>Specialist provides support and guidance for the Turner Mining Group- Bayer Phosphate and Silica <\/p>\n<p>Quarry Projects and other regional sites (as needed) while influencing employees to create safety <\/p>\n<p>ownership across all levels of the organization. The successful candidate must live the values and <\/p>\n<p>be an outward example to others. (An eye for Safety, and Attitude for Excellence, a mind for <\/p>\n<p>innovation, and a heart for people)<\/p>\n<p><\/p>\n<p><strong>Objectives and Contributions:<\/strong><\/p>\n<p>The Safety Support Specialist is focused on key aspects that drive wholistic safety ownership at a <\/p>\n<p>personal level. Many safety programs follow rigid requirements that are designed to \u201cthink\u201d for the <\/p>\n<p>employees. At Turner, we want to think outside the box. The key to a successful safety program is <\/p>\n<p>employee engagement, participation, and buy in.<\/p>\n<ul><li>Work directly with site leadership to ensure consistent use of systems, programs, and processes.<\/li><li>Support building a culture of Safe Production<\/li><li>Work with employees to ensure a high level of accuracy and engagement on hazard identification and control<strong> (Critical)<\/strong><\/li><li>Engage crews and leadership to define processes that motivate working towards common goals<\/li><li>Conduct and assist in managing Hearing Conservation testing under CAOHC Certification<\/li><li>Conduct and assist in managing Industrial Hygiene testing focused primarily on noise and dust exposure.<\/li><li>Assist with MSHA regulatory training and verify compliance to standards.<\/li><li>Live the values as part of a visible daily decision-making process<\/li><li>Audit sites while focusing on conditions and behaviors that reflect our desire to be the best in the business.<\/li><li>Assist in problem-solving including incident investigations, root cause analysis, and corrective action development.<\/li><li>Learn and assist with key performance indicators, company targets, and progress reporting.<\/li><li>Assist with and lead crew \/ supervision development opportunities.<\/li><li>Assist with client specific safety needs as required.<\/li><li>Support risk assessment processes at various levels of the organization including field level risk, project-based risk, and organizational risk management.<\/li><\/ul>\n<p><strong>Culture and Communication:<\/strong><\/p>\n<ul><li>Foster excitement throughout the organization by taking safety to new heights through cutting edge ideas and tactics.<\/li><li>Assist with site milestone recognition programs.<\/li><li>Assist with site communication programs and processes to ensure timely, specific, and value-added information.<\/li><li>Partner with site and project leaders to identify areas of improvement.<\/li><li>Develop and implement processes to reduce and eliminate repeat incidents<\/li><li>Assist site leaders with quality safety toolbox talks<\/li><li>Work with crews to support proactive near miss reporting.<\/li><li>Be visible with site leadership and crews. Spend time with Operations, Maintenance, and Site <\/li><li>Supervision to build relationships and develop trust.<\/li><\/ul>\n<p><strong>Systems:<\/strong><\/p>\n<ul><li>Support safety documentation platforms including HCSS, SharePoint, Adobe, and regulatory required systems.<\/li><li>Support incident tracking processes.<\/li><li>Ensure consistent use of root cause methodology<\/li><li>Implementation and use of risk analysis tools evaluating business processes and task-based risks<\/li><\/ul>\n<p><strong>Processes:<\/strong><\/p>\n<ul><li>Assist with leading and lagging indicators across the sites.<\/li><li>Work with leaders to develop ideas and improvement opportunities<\/li><li>Participate and support new project kick off requirements as well as closing other sites \/ projects.<\/li><li>Stay current with industry trends, regulations, and best practices in safety management, and recommend updates to company policies and procedures as needed.<\/li><li>Assist in writing and updating policies \/ procedures \/ and work instructions using professional writing language.<\/li><\/ul>\n<p><strong>Time and Interactions:<\/strong><\/p>\n<ul><li>This Safety Support Specialist role is based Bayer- Soda Springs, ID facilities but will also support other sites on an as needed basis.<\/li><li>This role is designed to be site based, however travel may be required.<\/li><li>The successful candidate will be self-starting, motivated, with a strong desire to be part of a team and to influence improvement.<\/li><li>Communication is also critical to keep leadership and site-based personnel in the loop of successes, challenges, and any additional support that may be required. Building credibility is key with the sites and supporting their safety needs.<\/li><\/ul>\n<p><strong>Qualifications:<\/strong><\/p>\n<ul><li>Microsoft Office proficiency<\/li><li>Must be motivated to look for site \/ crew \/ system improvement opportunities- Required<\/li><li>Proficiency in safety data and use of safety systems \u2013 Preferred<\/li><li>Ability to learn in a fast-paced environment - Required<\/li><li>Understanding of OSHA \/ MSHA regulatory requirements - Blue Card certification preferred<\/li><li>Bachelor\u2019s degree in occupational safety and health or equivalent preferred<\/li><li>3-8 years\u2019 experience in mining \/ heavy industry preferred<\/li><li>Working knowledge of safety systems and processes<\/li><li>Proficiency in written presentations and processes<\/li><li>Appropriate attention to detail required<\/li><li>The successful candidate must be passionate about their role and the success of Turner Mining Group.<\/li><\/ul>","post_title":"Safety Support Specialist","post_link":"https:\/\/turnerstaffing.com\/position\/safety-support-specialist\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Associate","%location_country%":"United States","%location_city%":"Soda Springs","%location_state_id%":"ID","%location_state_name%":"Idaho","%location_city_state%":"Soda Springs, ID","%education%":"Unspecified","%department%":"Safety","%description%":"<p><strong><u>Safety Support Specialist<\/u><\/strong><\/p>\n<p><strong>Reports to:<\/strong> Director of Safety \u2013 Turner Mining Group<\/p>\n<p><strong>Job Description:<\/strong><\/p>\n<p>The Safety Support Specialist is responsible for assisting with development, implementation, and <\/p>\n<p>oversight of our comprehensive safety program, ensuring compliance with all applicable regulatory <\/p>\n<p>requirements, and fostering a culture of safe operation within the organization. The Safety Support <\/p>\n<p>Specialist provides support and guidance for the Turner Mining Group- Bayer Phosphate and Silica <\/p>\n<p>Quarry Projects and other regional sites (as needed) while influencing employees to create safety <\/p>\n<p>ownership across all levels of the organization. The successful candidate must live the values and <\/p>\n<p>be an outward example to others. (An eye for Safety, and Attitude for Excellence, a mind for <\/p>\n<p>innovation, and a heart for people)<\/p>\n<p><\/p>\n<p><strong>Objectives and Contributions:<\/strong><\/p>\n<p>The Safety Support Specialist is focused on key aspects that drive wholistic safety ownership at a <\/p>\n<p>personal level. Many safety programs follow rigid requirements that are designed to \u201cthink\u201d for the <\/p>\n<p>employees. At Turner, we want to think outside the box. The key to a successful safety program is <\/p>\n<p>employee engagement, participation, and buy in.<\/p>\n<ul><li>Work directly with site leadership to ensure consistent use of systems, programs, and processes.<\/li><li>Support building a culture of Safe Production<\/li><li>Work with employees to ensure a high level of accuracy and engagement on hazard identification and control<strong> (Critical)<\/strong><\/li><li>Engage crews and leadership to define processes that motivate working towards common goals<\/li><li>Conduct and assist in managing Hearing Conservation testing under CAOHC Certification<\/li><li>Conduct and assist in managing Industrial Hygiene testing focused primarily on noise and dust exposure.<\/li><li>Assist with MSHA regulatory training and verify compliance to standards.<\/li><li>Live the values as part of a visible daily decision-making process<\/li><li>Audit sites while focusing on conditions and behaviors that reflect our desire to be the best in the business.<\/li><li>Assist in problem-solving including incident investigations, root cause analysis, and corrective action development.<\/li><li>Learn and assist with key performance indicators, company targets, and progress reporting.<\/li><li>Assist with and lead crew \/ supervision development opportunities.<\/li><li>Assist with client specific safety needs as required.<\/li><li>Support risk assessment processes at various levels of the organization including field level risk, project-based risk, and organizational risk management.<\/li><\/ul>\n<p><strong>Culture and Communication:<\/strong><\/p>\n<ul><li>Foster excitement throughout the organization by taking safety to new heights through cutting edge ideas and tactics.<\/li><li>Assist with site milestone recognition programs.<\/li><li>Assist with site communication programs and processes to ensure timely, specific, and value-added information.<\/li><li>Partner with site and project leaders to identify areas of improvement.<\/li><li>Develop and implement processes to reduce and eliminate repeat incidents<\/li><li>Assist site leaders with quality safety toolbox talks<\/li><li>Work with crews to support proactive near miss reporting.<\/li><li>Be visible with site leadership and crews. Spend time with Operations, Maintenance, and Site <\/li><li>Supervision to build relationships and develop trust.<\/li><\/ul>\n<p><strong>Systems:<\/strong><\/p>\n<ul><li>Support safety documentation platforms including HCSS, SharePoint, Adobe, and regulatory required systems.<\/li><li>Support incident tracking processes.<\/li><li>Ensure consistent use of root cause methodology<\/li><li>Implementation and use of risk analysis tools evaluating business processes and task-based risks<\/li><\/ul>\n<p><strong>Processes:<\/strong><\/p>\n<ul><li>Assist with leading and lagging indicators across the sites.<\/li><li>Work with leaders to develop ideas and improvement opportunities<\/li><li>Participate and support new project kick off requirements as well as closing other sites \/ projects.<\/li><li>Stay current with industry trends, regulations, and best practices in safety management, and recommend updates to company policies and procedures as needed.<\/li><li>Assist in writing and updating policies \/ procedures \/ and work instructions using professional writing language.<\/li><\/ul>\n<p><strong>Time and Interactions:<\/strong><\/p>\n<ul><li>This Safety Support Specialist role is based Bayer- Soda Springs, ID facilities but will also support other sites on an as needed basis.<\/li><li>This role is designed to be site based, however travel may be required.<\/li><li>The successful candidate will be self-starting, motivated, with a strong desire to be part of a team and to influence improvement.<\/li><li>Communication is also critical to keep leadership and site-based personnel in the loop of successes, challenges, and any additional support that may be required. Building credibility is key with the sites and supporting their safety needs.<\/li><\/ul>\n<p><strong>Qualifications:<\/strong><\/p>\n<ul><li>Microsoft Office proficiency<\/li><li>Must be motivated to look for site \/ crew \/ system improvement opportunities- Required<\/li><li>Proficiency in safety data and use of safety systems \u2013 Preferred<\/li><li>Ability to learn in a fast-paced environment - Required<\/li><li>Understanding of OSHA \/ MSHA regulatory requirements - Blue Card certification preferred<\/li><li>Bachelor\u2019s degree in occupational safety and health or equivalent preferred<\/li><li>3-8 years\u2019 experience in mining \/ heavy industry preferred<\/li><li>Working knowledge of safety systems and processes<\/li><li>Proficiency in written presentations and processes<\/li><li>Appropriate attention to detail required<\/li><li>The successful candidate must be passionate about their role and the success of Turner Mining Group.<\/li><\/ul>","%category%":"Operations","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/b969b95d9205-safety-support-specialist","%breezy_id%":"b969b95d9205","%breezy_friendly_id%":"b969b95d9205-safety-support-specialist","%breezy_created_date%":"2025-09-16T14:36:08.679Z","%breezy_updated_date%":"2025-10-13T14:30:20.462Z","%_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":2755,"infowindow_disable":false},{"source":"post","title":"Mining Electrician","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Mining Electrician\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    This role will carry out preventive and breakdown maintenance to fixed and mobile plant in an open cut environments. Duties&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/mining-electrician-2\/\" name=\"Mining Electrician\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"This role will carry out preventive and breakdown maintenance to fixed and mobile plant in an open cut environments. Duties&hellip;","address":"Gillette, WY, USA","location":{"lat":"44.2931097","city":"Gillette","state":"WY","country":"United States","lng":"-105.494199","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/mining-electrician-2\/","zoom":19,"extra_fields":{"post_excerpt":"This role will carry out preventive and breakdown maintenance to fixed and mobile plant in an open cut environments. Duties&hellip;","post_content":"<p>This role will carry out preventive and breakdown maintenance to fixed and mobile plant in an open cut environments.<\/p>\n<p><\/p>\n<p>Duties will include:<\/p>\n<ul><li>Visibly support and champion our client's Mission and Values<\/li><li>Act in accordance with and adhere to Safety as a Way of Life Management System<\/li><\/ul>\n<ul><li>Inspect work area and plant for hazards, damage and defects<\/li><li>Examine drawings or specifications to determine work methods, sequence of activities or manufacture of components<\/li><li>Diagnose faults or breakdowns<\/li><li>Estimate time and materials required to complete jobs<\/li><li>Raise orders for materials<\/li><li>Undertake repairs or component changeouts as required<\/li><li>Clean and maintain tools and work area<\/li><li>Train other personnel or apprentices (if required)<\/li><li>Ensure activities comply with safety, environmental and statutory requirements<\/li><li>Other duties as assigned by the company<\/li><\/ul>\n<p><\/p>\n<p><strong>The Lifestyle:<\/strong><\/p>\n<p>This position may require the necessity to work weekends, holidays, or another shift as deemed necessary.&nbsp;&nbsp;&nbsp;<br><\/p>\n<p><\/p>\n<p><strong>About you:<\/strong><\/p>\n<ul><li>Three years\u2019 experience performing electrical maintenance work in a heavy industrial environment or mine site is preferred.<\/li><li>Ability to solve problems and troubleshoot situations arising in the pit area as needed.<\/li><li>Ability to work in all types of weather conditions and at different times of day.<\/li><li>Ability to work a flexible schedule as required by business need.<\/li><li>Ability to work rotating shifts, weekends and overtime when required.<\/li><li>High School Degree or GED Equivalent required<\/li><\/ul>\n<p><\/p>\n<p><strong>Physical Requirements - Surface:<\/strong><\/p>\n<ul><li>Must have the ability to stand for up to 4 hours per shift<\/li><li>Must have the ability to be seated for up to 4 hours to operate equipment or vehicles<\/li><li>Must have the ability to work from elevated positions, walk\/climb up and down stairs\/steps and climb on and off equipment and ladders<\/li><li>Must have the ability to wear required protective footwear, hearing and eye protection, and other personal protective equipment as required by Company and MSHA<\/li><li>Must have the ability to perform repetitive hand and wrist motions (push, pull, twist, handle), and have rapid reflex movements of the arms and legs and good hand to eye coordination<\/li><li>Must have the ability to lift\/raise 10 - 50 lbs. without mechanical assistance frequently during the course of work shift&nbsp;<\/li><li>Must have the ability to work in extreme conditions, including but not limited to changing weather conditions, dust, mud, varying levels of noise from low to high, varying degrees of light and dark, in and around artificial light and in a confined work area<\/li><li>The job requires that you be able to work various shifts (required shifts include days, evenings and nights with rotating schedules, weekends and holidays&nbsp;&nbsp;&nbsp;<\/li><\/ul>","post_title":"Mining Electrician","post_link":"https:\/\/turnerstaffing.com\/position\/mining-electrician-2\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Mid Level","%location_country%":"United States","%location_city%":"Gillette","%location_state_id%":"WY","%location_state_name%":"Wyoming","%location_city_state%":"Gillette, WY","%education%":"High School or equivalent","%department%":"","%description%":"<p>This role will carry out preventive and breakdown maintenance to fixed and mobile plant in an open cut environments.<\/p>\n<p><\/p>\n<p>Duties will include:<\/p>\n<ul><li>Visibly support and champion our client's Mission and Values<\/li><li>Act in accordance with and adhere to Safety as a Way of Life Management System<\/li><\/ul>\n<ul><li>Inspect work area and plant for hazards, damage and defects<\/li><li>Examine drawings or specifications to determine work methods, sequence of activities or manufacture of components<\/li><li>Diagnose faults or breakdowns<\/li><li>Estimate time and materials required to complete jobs<\/li><li>Raise orders for materials<\/li><li>Undertake repairs or component changeouts as required<\/li><li>Clean and maintain tools and work area<\/li><li>Train other personnel or apprentices (if required)<\/li><li>Ensure activities comply with safety, environmental and statutory requirements<\/li><li>Other duties as assigned by the company<\/li><\/ul>\n<p><\/p>\n<p><strong>The Lifestyle:<\/strong><\/p>\n<p>This position may require the necessity to work weekends, holidays, or another shift as deemed necessary.&nbsp;&nbsp;&nbsp;<br><\/p>\n<p><\/p>\n<p><strong>About you:<\/strong><\/p>\n<ul><li>Three years\u2019 experience performing electrical maintenance work in a heavy industrial environment or mine site is preferred.<\/li><li>Ability to solve problems and troubleshoot situations arising in the pit area as needed.<\/li><li>Ability to work in all types of weather conditions and at different times of day.<\/li><li>Ability to work a flexible schedule as required by business need.<\/li><li>Ability to work rotating shifts, weekends and overtime when required.<\/li><li>High School Degree or GED Equivalent required<\/li><\/ul>\n<p><\/p>\n<p><strong>Physical Requirements - Surface:<\/strong><\/p>\n<ul><li>Must have the ability to stand for up to 4 hours per shift<\/li><li>Must have the ability to be seated for up to 4 hours to operate equipment or vehicles<\/li><li>Must have the ability to work from elevated positions, walk\/climb up and down stairs\/steps and climb on and off equipment and ladders<\/li><li>Must have the ability to wear required protective footwear, hearing and eye protection, and other personal protective equipment as required by Company and MSHA<\/li><li>Must have the ability to perform repetitive hand and wrist motions (push, pull, twist, handle), and have rapid reflex movements of the arms and legs and good hand to eye coordination<\/li><li>Must have the ability to lift\/raise 10 - 50 lbs. without mechanical assistance frequently during the course of work shift&nbsp;<\/li><li>Must have the ability to work in extreme conditions, including but not limited to changing weather conditions, dust, mud, varying levels of noise from low to high, varying degrees of light and dark, in and around artificial light and in a confined work area<\/li><li>The job requires that you be able to work various shifts (required shifts include days, evenings and nights with rotating schedules, weekends and holidays&nbsp;&nbsp;&nbsp;<\/li><\/ul>","%category%":"Operations","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/20b1e577c15e-mining-electrician","%breezy_id%":"20b1e577c15e","%breezy_friendly_id%":"20b1e577c15e-mining-electrician","%breezy_created_date%":"2025-09-16T15:45:41.918Z","%breezy_updated_date%":"2025-09-16T15:47:14.136Z","%_wpgmp_location_city%":"Gillette","%_wpgmp_location_state%":"WY","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Gillette, WY, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"44.2931097","%_wpgmp_metabox_longitude%":"-105.494199","%rank_math_internal_links_processed%":"1"}},"id":2756,"infowindow_disable":false},{"source":"post","title":"Project Engineer &#8211; Mining","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Project Engineer &#8211; Mining\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Project Engineer Advisor to Project Management Reports to Project Manager Reporting to the Project Manager, the Project Engineer plays a&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/project-engineer-mining-2\/\" 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":"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-engineer-mining-2\/","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\n\n\n\n<ul><li>Review operational reports (cost, safety, production) and analyze data for key trends.<\/li><li>Develop and implement continuous improvement initiatives to enhance efficiency and reduce costs.<\/li><li>Conduct risk assessments for operational, technical, and financial aspects of mining projects.<\/li><li>Collaborate with engineering and operations teams to optimize mine planning, design, and extraction techniques.<\/li><li>Develop and track key performance indicators (KPIs) to monitor operational performance and drive improvements.<\/li><\/ul>\n<p><strong>Mine Engineering &amp; Survey Duties<\/strong><\/p>\n\n\n\n\n\n<ul><li>Manage fleet management and high precision GPS systems.<\/li><li>Develop Drill &amp; Blast pattern, profile, and timing designs and short-range plans.<\/li><li>Produce road designs, stockpile and waste storage designs, and others in Hexagon MineSight.<\/li><li>Operate survey drones and reconcile results.<\/li><li>Analyze FMS and other data for risks and opportunities.<\/li><li>Audit and advise client on short range mine plans.<\/li><\/ul>\n<p><strong>Client &amp; Cross-Functional Collaboration<\/strong><\/p>\n\n\n\n<ul><li>Work closely with Turner Mining departments and external stakeholders to define project scopes and execution strategies.<\/li><li>Act as a technical link between client technical services and project management to ensure alignment on operational objectives.<\/li><li>Participate in knowledge-sharing initiatives, such as internal workshops and training, to support operational and analytical capabilities across teams.<\/li><li>Engage with suppliers and service providers to optimize procurement strategies for project operations.<\/li><\/ul>\n<p><strong>Compliance and Safety Integration<\/strong><\/p>\n\n\n<ul><li>Ensure that all engineering recommendations align with MSHA safety regulations and industry best practices.<\/li><li>Develop and maintain standard operating procedures (SOPs) for operational and safety processes.<\/li><li>Provide technical guidance to ensure site compliance with environmental and regulatory requirements.<\/li><\/ul>\n<ul><li>Other duties as required.<\/li><\/ul>\n<p><strong>The Ideal Candidate:<\/strong><\/p>\n<p><strong>Education and Experience<\/strong><\/p>\n\n\n\n\n\n<ul><li>Mining or Civil Engineering Degree or related.<\/li><li>3 years of mine site engineering or operational experience.<\/li><li>Hands-on experience with mining engineering software (Hexagon MineSight preferred or similar).<\/li><li>Strong proficiency in MS Office (Word, Excel, PowerPoint, Outlook).<\/li><li>Part 107 drone license preferred<\/li><li>Procurement and mine accounting experience preferred<\/li><\/ul>\n<p><strong>Technical and Analytical Skills<\/strong><\/p>\n\n\n\n<ul><li>Strong problem-solving and data analysis capabilities.<\/li><li>Ability to translate complex engineering data into actionable recommendations.<\/li><li>Knowledge of drill &amp; blast design, mine haulage analysis, and GPS fleet management.<\/li><li>Familiarity with mine accounting and procurement processes (preferred but not required).<\/li><\/ul>\n<p><strong>Key Competencies \/ Skills<\/strong><\/p>\n\n\n\n<ul><li>Results-oriented with a proactive, problem-solving mindset.<\/li><li>Effective communicator, capable of working with cross-functional teams and clients.<\/li><li>Ability to work independently and manage multiple priorities in a dynamic environment.<\/li><li>Detail-oriented with strong documentation and technical writing skills.<\/li><\/ul><p><strong><u>Benefits<\/u><\/strong><\/p>\n<p>Turner Mining Group offers a competitive salary, an excellent work culture, and career advancement opportunities. Our team provides a benefits program which includes Medical, Dental, Vision, Life, and a 401k with company match. We believe in a work-life balance and have established paid time off for major holidays.<\/p>\n<p>At Turner Mining Group, we encourage and celebrate an inclusive environment for all employees and are proud to be an equal opportunity workplace and affirmative action employer.<\/p>","post_title":"Project Engineer &#8211; Mining","post_link":"https:\/\/turnerstaffing.com\/position\/project-engineer-mining-2\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Mid Level","%location_country%":"United States","%location_city%":"Soda Springs","%location_state_id%":"ID","%location_state_name%":"Idaho","%location_city_state%":"Soda Springs, ID","%education%":"Unspecified","%department%":"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\n\n\n\n<ul><li>Review operational reports (cost, safety, production) and analyze data for key trends.<\/li><li>Develop and implement continuous improvement initiatives to enhance efficiency and reduce costs.<\/li><li>Conduct risk assessments for operational, technical, and financial aspects of mining projects.<\/li><li>Collaborate with engineering and operations teams to optimize mine planning, design, and extraction techniques.<\/li><li>Develop and track key performance indicators (KPIs) to monitor operational performance and drive improvements.<\/li><\/ul>\n<p><strong>Mine Engineering &amp; Survey Duties<\/strong><\/p>\n\n\n\n\n\n<ul><li>Manage fleet management and high precision GPS systems.<\/li><li>Develop Drill &amp; Blast pattern, profile, and timing designs and short-range plans.<\/li><li>Produce road designs, stockpile and waste storage designs, and others in Hexagon MineSight.<\/li><li>Operate survey drones and reconcile results.<\/li><li>Analyze FMS and other data for risks and opportunities.<\/li><li>Audit and advise client on short range mine plans.<\/li><\/ul>\n<p><strong>Client &amp; Cross-Functional Collaboration<\/strong><\/p>\n\n\n\n<ul><li>Work closely with Turner Mining departments and external stakeholders to define project scopes and execution strategies.<\/li><li>Act as a technical link between client technical services and project management to ensure alignment on operational objectives.<\/li><li>Participate in knowledge-sharing initiatives, such as internal workshops and training, to support operational and analytical capabilities across teams.<\/li><li>Engage with suppliers and service providers to optimize procurement strategies for project operations.<\/li><\/ul>\n<p><strong>Compliance and Safety Integration<\/strong><\/p>\n\n\n<ul><li>Ensure that all engineering recommendations align with MSHA safety regulations and industry best practices.<\/li><li>Develop and maintain standard operating procedures (SOPs) for operational and safety processes.<\/li><li>Provide technical guidance to ensure site compliance with environmental and regulatory requirements.<\/li><\/ul>\n<ul><li>Other duties as required.<\/li><\/ul>\n<p><strong>The Ideal Candidate:<\/strong><\/p>\n<p><strong>Education and Experience<\/strong><\/p>\n\n\n\n\n\n<ul><li>Mining or Civil Engineering Degree or related.<\/li><li>3 years of mine site engineering or operational experience.<\/li><li>Hands-on experience with mining engineering software (Hexagon MineSight preferred or similar).<\/li><li>Strong proficiency in MS Office (Word, Excel, PowerPoint, Outlook).<\/li><li>Part 107 drone license preferred<\/li><li>Procurement and mine accounting experience preferred<\/li><\/ul>\n<p><strong>Technical and Analytical Skills<\/strong><\/p>\n\n\n\n<ul><li>Strong problem-solving and data analysis capabilities.<\/li><li>Ability to translate complex engineering data into actionable recommendations.<\/li><li>Knowledge of drill &amp; blast design, mine haulage analysis, and GPS fleet management.<\/li><li>Familiarity with mine accounting and procurement processes (preferred but not required).<\/li><\/ul>\n<p><strong>Key Competencies \/ Skills<\/strong><\/p>\n\n\n\n<ul><li>Results-oriented with a proactive, problem-solving mindset.<\/li><li>Effective communicator, capable of working with cross-functional teams and clients.<\/li><li>Ability to work independently and manage multiple priorities in a dynamic environment.<\/li><li>Detail-oriented with strong documentation and technical writing skills.<\/li><\/ul><p><strong><u>Benefits<\/u><\/strong><\/p>\n<p>Turner Mining Group offers a competitive salary, an excellent work culture, and career advancement opportunities. Our team provides a benefits program which includes Medical, Dental, Vision, Life, and a 401k with company match. We believe in a work-life balance and have established paid time off for major holidays.<\/p>\n<p>At Turner Mining Group, we encourage and celebrate an inclusive environment for all employees and are proud to be an equal opportunity workplace and affirmative action employer.<\/p>","%category%":"Other","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/c6e8d4bd2abf-project-engineer-mining","%breezy_id%":"c6e8d4bd2abf","%breezy_friendly_id%":"c6e8d4bd2abf-project-engineer-mining","%breezy_created_date%":"2025-09-15T20:23:51.479Z","%breezy_updated_date%":"2025-10-09T18:00:40.781Z","%_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":2754,"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-2\/\" 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":"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\/operations-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<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-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 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\/2e1dbb92354e-operations-superintendent-mining","%breezy_id%":"2e1dbb92354e","%breezy_friendly_id%":"2e1dbb92354e-operations-superintendent-mining","%breezy_created_date%":"2025-09-15T20:02:34.377Z","%breezy_updated_date%":"2025-10-09T17:59:59.709Z","%_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":2752,"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    Foreman Manages a crew, shift, or specific task Reports to Project Superintendent Project Management Follow TMG process for daily entries&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/mining-foreman\/\" name=\"Mining Foreman\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Foreman Manages a crew, shift, or specific task Reports to Project Superintendent Project Management Follow TMG process for daily entries&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-foreman\/","zoom":19,"extra_fields":{"post_excerpt":"Foreman Manages a crew, shift, or specific task Reports to Project Superintendent Project Management Follow TMG process for daily entries&hellip;","post_content":"<p><strong><u>Foreman<\/u><\/strong><\/p>\n<p><strong>Manages a crew, shift, or specific task<\/strong><\/p>\n<p><strong>Reports to Project Superintendent<\/strong><\/p>\n<p><u>Project Management<\/u><\/p>\n\n\n\n\n\n\n<ul><li>Follow TMG process for daily entries into Project Management System <\/li><li>Submit daily timecards that include employee time for payroll, equipment hours (operated, down,and standby), and quantities\/ billable items for the shift<\/li><li>Include detailed notes in the project diary submission<\/li><li>Check grade with GPS unit to check work completion (when no Project Engineer)<\/li><li>Ensure site conditions promote safety, efficiency, and minimize equipment wear\/ damage<\/li><li>50% or more of time should be spent in the field monitoring production activities<\/li><\/ul>\n<p><u>Safety Leadership<\/u>&nbsp;<\/p>\n\n\n\n\n\n\n<ul><li>Lead pre-shift Safety meetings every shift with Superintendent, cover relevant safety topics and engage crews in discussion<\/li><li>Ensure all MSHA regulations are followed and maintain site safety conditions<\/li><li>Complete workplace exams before each shift<\/li><li>Complete task training using 5000-23 forms utilizing the TMG process for form completion<\/li><li>Follow TMG process for completing pre-op forms from employees, submit all paperwork to Superintendent<\/li><li>Follow TMG process for incident response, notify Superintendent.<\/li><\/ul>\n<p><u>Personnel Management<\/u>&nbsp;<\/p>\n\n\n\n<ul><li>Notify Superintendent of personnel issues. Resolve issues requiring immediate attention. <\/li><li>Maintain full knowledge of employee handbook<\/li><li>Advise Superintendent on personnel needs\/ changes. <\/li><li>Advise Superintendent on employee performance for employee reviews<\/li><\/ul>\n<p><u>Proficiencies<\/u><\/p>\n\n\n<ul><li>HeavyJob<\/li><li>Slack<\/li><li>Excel<\/li><li>Email<\/li><\/ul><p><u>Benefits<\/u><u><br><\/u><br>Turner Mining Group offers a competitive salary, an excellent work culture, and career advancement&nbsp;opportunities. Our team provides a benefits program which includes Medical, Dental, Vision, Life, and a&nbsp;401k with company match. We believe in a work-life balance and have established paid time off for major<br>holidays.<\/p><p>At Turner Mining Group, we encourage and celebrate an inclusive environment for all employees and are&nbsp;proud to be an equal opportunity workplace and affirmative action employer.<\/p>","post_title":"Mining Foreman","post_link":"https:\/\/turnerstaffing.com\/position\/mining-foreman\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Mid Level","%location_country%":"United States","%location_city%":"Soda Springs","%location_state_id%":"ID","%location_state_name%":"Idaho","%location_city_state%":"Soda Springs, ID","%education%":"Unspecified","%department%":"Operations","%description%":"<p><strong><u>Foreman<\/u><\/strong><\/p>\n<p><strong>Manages a crew, shift, or specific task<\/strong><\/p>\n<p><strong>Reports to Project Superintendent<\/strong><\/p>\n<p><u>Project Management<\/u><\/p>\n\n\n\n\n\n\n<ul><li>Follow TMG process for daily entries into Project Management System <\/li><li>Submit daily timecards that include employee time for payroll, equipment hours (operated, down,and standby), and quantities\/ billable items for the shift<\/li><li>Include detailed notes in the project diary submission<\/li><li>Check grade with GPS unit to check work completion (when no Project Engineer)<\/li><li>Ensure site conditions promote safety, efficiency, and minimize equipment wear\/ damage<\/li><li>50% or more of time should be spent in the field monitoring production activities<\/li><\/ul>\n<p><u>Safety Leadership<\/u>&nbsp;<\/p>\n\n\n\n\n\n\n<ul><li>Lead pre-shift Safety meetings every shift with Superintendent, cover relevant safety topics and engage crews in discussion<\/li><li>Ensure all MSHA regulations are followed and maintain site safety conditions<\/li><li>Complete workplace exams before each shift<\/li><li>Complete task training using 5000-23 forms utilizing the TMG process for form completion<\/li><li>Follow TMG process for completing pre-op forms from employees, submit all paperwork to Superintendent<\/li><li>Follow TMG process for incident response, notify Superintendent.<\/li><\/ul>\n<p><u>Personnel Management<\/u>&nbsp;<\/p>\n\n\n\n<ul><li>Notify Superintendent of personnel issues. Resolve issues requiring immediate attention. <\/li><li>Maintain full knowledge of employee handbook<\/li><li>Advise Superintendent on personnel needs\/ changes. <\/li><li>Advise Superintendent on employee performance for employee reviews<\/li><\/ul>\n<p><u>Proficiencies<\/u><\/p>\n\n\n<ul><li>HeavyJob<\/li><li>Slack<\/li><li>Excel<\/li><li>Email<\/li><\/ul><p><u>Benefits<\/u><u><br><\/u><br>Turner Mining Group offers a competitive salary, an excellent work culture, and career advancement&nbsp;opportunities. Our team provides a benefits program which includes Medical, Dental, Vision, Life, and a&nbsp;401k with company match. We believe in a work-life balance and have established paid time off for major<br>holidays.<\/p><p>At Turner Mining Group, we encourage and celebrate an inclusive environment for all employees and are&nbsp;proud to be an equal opportunity workplace and affirmative action employer.<\/p>","%category%":"Operations","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/d661f48c24b8-mining-foreman","%breezy_id%":"d661f48c24b8","%breezy_friendly_id%":"d661f48c24b8-mining-foreman","%breezy_created_date%":"2025-09-15T20:18:32.530Z","%breezy_updated_date%":"2025-09-15T20:19:10.891Z","%_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":2753,"infowindow_disable":false},{"source":"post","title":"Equipment Superintendent","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Equipment Superintendent\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Equipment Superintendent Job Description Manage Project maintenance and Equipment Vendor personnel Reports to Project Manager Safety Leadership Invest, teach, and&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/equipment-superintendent\/\" name=\"Equipment Superintendent\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Equipment Superintendent Job Description Manage Project maintenance and Equipment Vendor personnel Reports to Project Manager Safety Leadership Invest, teach, and&hellip;","address":"Soda Springs, ID, USA","location":{"lat":"42.6543652","city":"Soda Springs","state":"ID","country":"United States","lng":"-111.6046687","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/equipment-superintendent\/","zoom":19,"extra_fields":{"post_excerpt":"Equipment Superintendent Job Description Manage Project maintenance and Equipment Vendor personnel Reports to Project Manager Safety Leadership Invest, teach, and&hellip;","post_content":"<p><strong><u>Equipment Superintendent Job Description<\/u><\/strong><\/p><p><strong>Manage Project maintenance and Equipment Vendor personnel Reports to Project Manager<\/strong><\/p>\n\n<p><strong><u>Safety Leadership<\/u><\/strong><\/p>\n\n\n\n\n\n\n\n\n\n\n\n\n<ul><li>Invest, teach, and mentor project maintenance personnel to foster \"An Eye For Safety\u201d environment at the site<\/li><li>Mitigate onsite safety risks<\/li><li>Ensure all MSHA regulations are followed and maintain site safety standards<\/li><li>Conduct and participate in monthly site safety meetings to discuss incidents, safety trends, behavior goals, etc.<\/li><li>Ensure all workplace exams are complete and accurate<\/li><li>Task training is completed correctly and stored<\/li><li>Pre-operational inspection issues are corrected, and forms are filed according to the TMG process<\/li><li>All safety documents are filed and stored on-site<\/li><li>Follow the TMG process for incident investigation and response<\/li><li>Complete incident report in HCSS Safety<\/li><li>Provide employees with a safe and healthy work environment by providing safe systems of work, safe work procedures, adequate training and instruction, and competent supervision<\/li><li>Review hazard identification, near miss, and incident reports and provide follow-up as appropriate<\/li><li>Ensure maintenance employees and contractors working within the Site Project personnel are prequalified and have the necessary commencement paperwork, competencies, and qualifications to work safely and deliver quality maintenance services (has Stop Work Authority if standards are not met)<\/li><\/ul>\n<p><strong><u>Major Responsibilities<\/u><\/strong><\/p>\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n<ul><li>Spend considerable time in the field interacting with the workforce \u2013 Creating \u201c<strong>visible felt<\/strong> <strong>leadership<\/strong>\u201d ~25 to 40% of working time<\/li><li>TMG fuel and lube technicians will report to the role<\/li><li>Manager equipment vendor maintenance personnel and coordinate their site activities<\/li><li>Develop systems and foster the required collaboration to ensure the department meets monthly targets<\/li><li>Review competencies, Scopes of Work, and Schedules of Rates for all Contractors, ensuring costs are managed and controlled while complying with Contractor Controls Policies and Procedures<\/li><li>Help develop maintenance strategy objectives and ensure they are met<\/li><li>Improve Equipment\/Operations Performance by Optimize Equipment &amp; Fleet Asset Reliability<\/li><li>Ensure the effective and efficient application of maintenance resources, as measured by schedule compliance, PM compliance, the level of planned vs. unplanned work, and the ongoing management of backlog<\/li><li>Create service requests, work orders, and purchase orders for repairs\/purchases in the TMG accounting systems and communicating with vendors during the purchase process<\/li><li>Assist Project Manager as needed with tracking maintenance costs and accounting<\/li><li>Participate in incident investigations (injury, high-potential, and equipment damage) to ensure that corrective actions are effectively implemented and tracked<\/li><li>Support the development and ongoing optimization of maintenance strategies for critical assets.<\/li><li>Complete performance evaluation reviews for direct reports and manage their career development.<\/li><li>Recruit for Maintenance positions. Ensure that succession planning for critical roles is in place<\/li><li>Ensure applicable maintenance training is provided as required<\/li><li>Communicate daily needs with Project team<\/li><li>Develop an equipment coordinator position if the need arises in the future<\/li><li>Manage equipment costs, repairs, rebuilds, warrantee items, and equipment replacements<\/li><li>Manage field services for operations: service and mechanics trucks, tools, etc.<\/li><li>These responsibilities are required but not limited to and others may be assigned by the Project Manager as needed<\/li><\/ul>\n<p><strong><u>Preferred Candidate Requirements: <\/u><\/strong><\/p>\n\n<ul><li>Minimum 5-7 years Maintenance General Foreman level or higher experience in heavy industry<\/li><li>Minimum of 4 years of management of the maintenance scheduling and workflow function<\/li><\/ul>\n<p><strong><u>Personnel Management<\/u><\/strong><\/p>\n\n\n\n\n\n<ul><li>Submit hiring requests\/termination requisitions to HR following the TMG process<\/li><li>Conduct interviews for maintenance employees<\/li><li>Complete employee reviews using the TMG form and submit them for approval<\/li><li>Evaluate maintenance personnel performance<\/li><li>Document employee issues\/ disciplinary action, send to Project Manager and HR<\/li><li>Maintain complete knowledge of the employee handbook<\/li><\/ul>\n<p><strong><u>Benefits<\/u><\/strong><\/p>\n<p>Turner Mining Group offers a competitive salary, an excellent work culture, and career advancement opportunities. Our team provides a benefits program which includes Medical, Dental, Vision, Life, and a 401k with company match. We believe in a work-life balance and have established paid time off for major holidays.<\/p>\n<p>At Turner Mining Group, we encourage and celebrate an inclusive environment for all employees and are proud to be an equal opportunity workplace and affirmative action employer.<\/p>","post_title":"Equipment Superintendent","post_link":"https:\/\/turnerstaffing.com\/position\/equipment-superintendent\/","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%":"Equipment","%description%":"<p><strong><u>Equipment Superintendent Job Description<\/u><\/strong><\/p><p><strong>Manage Project maintenance and Equipment Vendor personnel Reports to Project Manager<\/strong><\/p>\n\n<p><strong><u>Safety Leadership<\/u><\/strong><\/p>\n\n\n\n\n\n\n\n\n\n\n\n\n<ul><li>Invest, teach, and mentor project maintenance personnel to foster \"An Eye For Safety\u201d environment at the site<\/li><li>Mitigate onsite safety risks<\/li><li>Ensure all MSHA regulations are followed and maintain site safety standards<\/li><li>Conduct and participate in monthly site safety meetings to discuss incidents, safety trends, behavior goals, etc.<\/li><li>Ensure all workplace exams are complete and accurate<\/li><li>Task training is completed correctly and stored<\/li><li>Pre-operational inspection issues are corrected, and forms are filed according to the TMG process<\/li><li>All safety documents are filed and stored on-site<\/li><li>Follow the TMG process for incident investigation and response<\/li><li>Complete incident report in HCSS Safety<\/li><li>Provide employees with a safe and healthy work environment by providing safe systems of work, safe work procedures, adequate training and instruction, and competent supervision<\/li><li>Review hazard identification, near miss, and incident reports and provide follow-up as appropriate<\/li><li>Ensure maintenance employees and contractors working within the Site Project personnel are prequalified and have the necessary commencement paperwork, competencies, and qualifications to work safely and deliver quality maintenance services (has Stop Work Authority if standards are not met)<\/li><\/ul>\n<p><strong><u>Major Responsibilities<\/u><\/strong><\/p>\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n<ul><li>Spend considerable time in the field interacting with the workforce \u2013 Creating \u201c<strong>visible felt<\/strong> <strong>leadership<\/strong>\u201d ~25 to 40% of working time<\/li><li>TMG fuel and lube technicians will report to the role<\/li><li>Manager equipment vendor maintenance personnel and coordinate their site activities<\/li><li>Develop systems and foster the required collaboration to ensure the department meets monthly targets<\/li><li>Review competencies, Scopes of Work, and Schedules of Rates for all Contractors, ensuring costs are managed and controlled while complying with Contractor Controls Policies and Procedures<\/li><li>Help develop maintenance strategy objectives and ensure they are met<\/li><li>Improve Equipment\/Operations Performance by Optimize Equipment &amp; Fleet Asset Reliability<\/li><li>Ensure the effective and efficient application of maintenance resources, as measured by schedule compliance, PM compliance, the level of planned vs. unplanned work, and the ongoing management of backlog<\/li><li>Create service requests, work orders, and purchase orders for repairs\/purchases in the TMG accounting systems and communicating with vendors during the purchase process<\/li><li>Assist Project Manager as needed with tracking maintenance costs and accounting<\/li><li>Participate in incident investigations (injury, high-potential, and equipment damage) to ensure that corrective actions are effectively implemented and tracked<\/li><li>Support the development and ongoing optimization of maintenance strategies for critical assets.<\/li><li>Complete performance evaluation reviews for direct reports and manage their career development.<\/li><li>Recruit for Maintenance positions. Ensure that succession planning for critical roles is in place<\/li><li>Ensure applicable maintenance training is provided as required<\/li><li>Communicate daily needs with Project team<\/li><li>Develop an equipment coordinator position if the need arises in the future<\/li><li>Manage equipment costs, repairs, rebuilds, warrantee items, and equipment replacements<\/li><li>Manage field services for operations: service and mechanics trucks, tools, etc.<\/li><li>These responsibilities are required but not limited to and others may be assigned by the Project Manager as needed<\/li><\/ul>\n<p><strong><u>Preferred Candidate Requirements: <\/u><\/strong><\/p>\n\n<ul><li>Minimum 5-7 years Maintenance General Foreman level or higher experience in heavy industry<\/li><li>Minimum of 4 years of management of the maintenance scheduling and workflow function<\/li><\/ul>\n<p><strong><u>Personnel Management<\/u><\/strong><\/p>\n\n\n\n\n\n<ul><li>Submit hiring requests\/termination requisitions to HR following the TMG process<\/li><li>Conduct interviews for maintenance employees<\/li><li>Complete employee reviews using the TMG form and submit them for approval<\/li><li>Evaluate maintenance personnel performance<\/li><li>Document employee issues\/ disciplinary action, send to Project Manager and HR<\/li><li>Maintain complete knowledge of the employee handbook<\/li><\/ul>\n<p><strong><u>Benefits<\/u><\/strong><\/p>\n<p>Turner Mining Group offers a competitive salary, an excellent work culture, and career advancement opportunities. Our team provides a benefits program which includes Medical, Dental, Vision, Life, and a 401k with company match. We believe in a work-life balance and have established paid time off for major holidays.<\/p>\n<p>At Turner Mining Group, we encourage and celebrate an inclusive environment for all employees and are proud to be an equal opportunity workplace and affirmative action employer.<\/p>","%category%":"Other","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/3bd63cb3b8ea-equipment-superintendent","%breezy_id%":"3bd63cb3b8ea","%breezy_friendly_id%":"3bd63cb3b8ea-equipment-superintendent","%breezy_created_date%":"2025-09-15T19:23:42.979Z","%breezy_updated_date%":"2025-09-15T19:24:47.738Z","%_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":2751,"infowindow_disable":false},{"source":"post","title":"Maintenance Superintendent","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Maintenance Superintendent\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Turner Mining Group &#8211; Equipment Superintendent We are looking for a dynamic and talented Equipment Superintendent at our fast-growing, forward&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/maintenance-superintendent\/\" name=\"Maintenance Superintendent\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Turner Mining Group &#8211; Equipment Superintendent We are looking for a dynamic and talented Equipment Superintendent at our fast-growing, forward&hellip;","address":"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-superintendent\/","zoom":19,"extra_fields":{"post_excerpt":"Turner Mining Group &#8211; Equipment Superintendent We are looking for a dynamic and talented Equipment Superintendent at our fast-growing, forward&hellip;","post_content":"<p><strong><u>Turner Mining Group - Equipment Superintendent <\/u><\/strong><br><\/p>\n\n<p>We are looking for a dynamic and talented Equipment Superintendent at our fast-growing, forward thinking mining services company!  This position will report directly to the Regional Equipment Manager. <\/p>\n<p><strong>Major Responsibilities:<\/strong><\/p>\n<ul><li>Safety performance of the Maintenance Department. <\/li><li>Ensure deployment of key initiatives and communication of relevant messages to all maintenance crews at site.<\/li><li>Effectively promote, deploy, and comply with all Safety &amp; Health and Environmental policies, standards, procedures and regulations across Ledcor and Maintenance.<\/li><li>Spend significant time in the field \u2013 \u201cvisible felt leadership\u201d \u2013 interacting with the workforce, ~40 - 60% of working time.<\/li><li>Provide employees with a safe and healthy work environment by ensuring provision of safe systems of work; safe work procedures; adequate training and instruction; competent supervision. <\/li><li>Develop systems and foster the required collaboration to ensure the department meets monthly targets.<\/li><li>Review competencies, Scopes of Work and Schedules of Rates for all Contractors ensuring costs are managed and controlled while complying with Contractor Controls Policies and Procedures.<\/li><li>Help develop maintenance strategy objectives and ensure they are met.<\/li><li>Ensure effective and efficient application of maintenance resources as measured by schedule compliance, PM compliance, level of planned vs. unplanned work and the ongoing management of backlog.<\/li><li>Review hazard identification, near miss and incident reports and provide follow-up as appropriate<\/li><li>Participate in incident investigations (injury, high-potential and equipment damage) as required ensure that corrective actions are effectively implemented and tracked. <\/li><li>Ensure maintenance employees and contractors working within the Group are prequalified and have the necessary commencement paperwork, competencies and qualifications to work safely and deliver quality maintenance services (has the authority to prohibit any work from being undertaken unless all requirements are met). <\/li><li>Support the development and ongoing optimization of maintenance strategies for the critical assets. <\/li><li>Ensure that all maintenance activities are scheduled effectively, utilizing business processes and supporting systems.<\/li><li>Complete performance evaluation reviews for direct reports and manage their career development.<\/li><li>Recruit for Maintenance positions. Ensure that succession planning for key roles is in place.<\/li><li>Ensure training is provided as required.<\/li><\/ul>\n<p>  <\/p>\n<p><strong>Requirements: <\/strong><\/p>\n<p><u>Essential<\/u><\/p>\n<ul><li>Minimum 3-5 years Maintenance General Foreman level or higher experience in heavy industry<\/li><li>Minimum 2+ years management of the maintenance scheduling and work flow function.<\/li><\/ul>\n<p><u>Desirable<\/u><\/p>\n<ul><li>Experience managing or supervising an equipment department<\/li><li>5 years\u2019 experience in managing maintenance.<\/li><li>Exposure to Project Management tools and techniques.<\/li><\/ul>\n<p><strong>Benefits<\/strong><\/p>\n<p>Turner Mining Group offers a competitive salary, an excellent work culture, career advancement opportunities. Our team offers a benefits program which includes Medical, Dental, Vision, Life, and a 401k with company match.  We believe in a work life balance and established paid time off for major holidays.<\/p>\n<p>At Turner Mining Group, we encourage and celebrate an inclusive environment for all employees and are proud to be an equal opportunity workplace and affirmative action employer.<\/p>","post_title":"Maintenance Superintendent","post_link":"https:\/\/turnerstaffing.com\/position\/maintenance-superintendent\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Mid Level","%location_country%":"United States","%location_city%":"Crane","%location_state_id%":"TX","%location_state_name%":"Texas","%location_city_state%":"Crane, TX","%education%":"Unspecified","%department%":"Maintenance","%description%":"<p><strong><u>Turner Mining Group - Equipment Superintendent <\/u><\/strong><br><\/p>\n\n<p>We are looking for a dynamic and talented Equipment Superintendent at our fast-growing, forward thinking mining services company!  This position will report directly to the Regional Equipment Manager. <\/p>\n<p><strong>Major Responsibilities:<\/strong><\/p>\n<ul><li>Safety performance of the Maintenance Department. <\/li><li>Ensure deployment of key initiatives and communication of relevant messages to all maintenance crews at site.<\/li><li>Effectively promote, deploy, and comply with all Safety &amp; Health and Environmental policies, standards, procedures and regulations across Ledcor and Maintenance.<\/li><li>Spend significant time in the field \u2013 \u201cvisible felt leadership\u201d \u2013 interacting with the workforce, ~40 - 60% of working time.<\/li><li>Provide employees with a safe and healthy work environment by ensuring provision of safe systems of work; safe work procedures; adequate training and instruction; competent supervision. <\/li><li>Develop systems and foster the required collaboration to ensure the department meets monthly targets.<\/li><li>Review competencies, Scopes of Work and Schedules of Rates for all Contractors ensuring costs are managed and controlled while complying with Contractor Controls Policies and Procedures.<\/li><li>Help develop maintenance strategy objectives and ensure they are met.<\/li><li>Ensure effective and efficient application of maintenance resources as measured by schedule compliance, PM compliance, level of planned vs. unplanned work and the ongoing management of backlog.<\/li><li>Review hazard identification, near miss and incident reports and provide follow-up as appropriate<\/li><li>Participate in incident investigations (injury, high-potential and equipment damage) as required ensure that corrective actions are effectively implemented and tracked. <\/li><li>Ensure maintenance employees and contractors working within the Group are prequalified and have the necessary commencement paperwork, competencies and qualifications to work safely and deliver quality maintenance services (has the authority to prohibit any work from being undertaken unless all requirements are met). <\/li><li>Support the development and ongoing optimization of maintenance strategies for the critical assets. <\/li><li>Ensure that all maintenance activities are scheduled effectively, utilizing business processes and supporting systems.<\/li><li>Complete performance evaluation reviews for direct reports and manage their career development.<\/li><li>Recruit for Maintenance positions. Ensure that succession planning for key roles is in place.<\/li><li>Ensure training is provided as required.<\/li><\/ul>\n<p>  <\/p>\n<p><strong>Requirements: <\/strong><\/p>\n<p><u>Essential<\/u><\/p>\n<ul><li>Minimum 3-5 years Maintenance General Foreman level or higher experience in heavy industry<\/li><li>Minimum 2+ years management of the maintenance scheduling and work flow function.<\/li><\/ul>\n<p><u>Desirable<\/u><\/p>\n<ul><li>Experience managing or supervising an equipment department<\/li><li>5 years\u2019 experience in managing maintenance.<\/li><li>Exposure to Project Management tools and techniques.<\/li><\/ul>\n<p><strong>Benefits<\/strong><\/p>\n<p>Turner Mining Group offers a competitive salary, an excellent work culture, career advancement opportunities. Our team offers a benefits program which includes Medical, Dental, Vision, Life, and a 401k with company match.  We believe in a work life balance and established paid time off for major holidays.<\/p>\n<p>At Turner Mining Group, we encourage and celebrate an inclusive environment for all employees and are proud to be an equal opportunity workplace and affirmative action employer.<\/p>","%category%":"Management","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/5140ca2a9fc8-maintenance-superintendent","%breezy_id%":"5140ca2a9fc8","%breezy_friendly_id%":"5140ca2a9fc8-maintenance-superintendent","%breezy_created_date%":"2024-11-21T14:54:19.587Z","%breezy_updated_date%":"2025-09-12T15:07:33.283Z","%_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":2742,"infowindow_disable":false},{"source":"post","title":"Heavy Equipment Operator","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Heavy Equipment Operator\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    About the Role Turner Staffing Group, in partnership with a leading mining company specializing in crushing operations, is seeking a&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/heavy-equipment-operator-5\/\" name=\"Heavy Equipment Operator\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"About the Role Turner Staffing Group, in partnership with a leading mining company specializing in crushing operations, is seeking a&hellip;","address":"Wyalusing, PA, USA","location":{"lat":"41.6681309","city":"Wyalusing","state":"PA","country":"United States","lng":"-76.2618786","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/heavy-equipment-operator-5\/","zoom":19,"extra_fields":{"post_excerpt":"About the Role Turner Staffing Group, in partnership with a leading mining company specializing in crushing operations, is seeking a&hellip;","post_content":"<h3><strong>About the Role<\/strong><\/h3>\n<p>Turner Staffing Group, in partnership with a leading mining company specializing in crushing operations, is seeking a skilled <strong>Heavy Equipment Operator<\/strong> to join our team. This position is ideal for individuals who have hands-on experience with large-scale equipment in a mining or aggregate environment and who thrive in a team-oriented workplace.<\/p>\n<h3><strong>Key Responsibilities<\/strong><\/h3>\n<ul>\n<li>\n<p>Operate heavy equipment safely and efficiently, including:<\/p>\n<ul>\n<li>\n<p><strong>CAT 980 and CAT 988 loaders<\/strong><\/p>\n<\/li>\n<li>\n<p><strong>CAT 350 excavators<\/strong><\/p>\n<\/li>\n<\/ul>\n<\/li>\n<li>\n<p>Support crushing operations by moving, loading, and feeding material.<\/p>\n<\/li>\n<li>\n<p>Perform basic equipment maintenance, inspections, and minor repairs to ensure reliable operation.<\/p>\n<\/li>\n<li>\n<p>Adhere to all company safety policies, site regulations, and environmental standards.<\/p>\n<\/li>\n<li>\n<p>Collaborate with team members and supervisors to achieve production targets.<\/p>\n<\/li>\n<li>\n<p>Maintain a clean, organized, and safe work area.<\/p>\n<\/li>\n<\/ul>\n<h3><strong>Qualifications<\/strong><\/h3>\n<ul>\n<li>\n<p>Proven experience operating <strong>CAT 980\/CAT 988 loaders<\/strong> and <strong>CAT 350 excavators<\/strong> in a mining or aggregate setting.<\/p>\n<\/li>\n<li>\n<p>Basic mechanical and maintenance skills, with the ability to troubleshoot and assist with minor repairs.<\/p>\n<\/li>\n<li>\n<p>Strong awareness of safety protocols and best practices in a mining environment.<\/p>\n<\/li>\n<li>\n<p>Reliable, with a <strong>team player attitude<\/strong> and willingness to pitch in wherever needed.<\/p>\n<\/li>\n<li>\n<p>Excellent communication skills and the ability to work effectively with others.<\/p>\n<\/li>\n<\/ul>\n<h3><strong>Why Join Us?<\/strong><\/h3>\n<ul>\n<li>\n<p>Competitive pay and benefits.<\/p>\n<\/li>\n<li>\n<p>Opportunity to work with an established mining operation.<\/p>\n<\/li>\n<li>\n<p>Supportive, safety-focused team environment.<\/p><\/li><\/ul>","post_title":"Heavy Equipment Operator","post_link":"https:\/\/turnerstaffing.com\/position\/heavy-equipment-operator-5\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"","%location_country%":"United States","%location_city%":"Wyalusing","%location_state_id%":"PA","%location_state_name%":"Pennsylvania","%location_city_state%":"Wyalusing, PA","%education%":"","%department%":"","%description%":"<h3><strong>About the Role<\/strong><\/h3>\n<p>Turner Staffing Group, in partnership with a leading mining company specializing in crushing operations, is seeking a skilled <strong>Heavy Equipment Operator<\/strong> to join our team. This position is ideal for individuals who have hands-on experience with large-scale equipment in a mining or aggregate environment and who thrive in a team-oriented workplace.<\/p>\n<h3><strong>Key Responsibilities<\/strong><\/h3>\n<ul>\n<li>\n<p>Operate heavy equipment safely and efficiently, including:<\/p>\n<ul>\n<li>\n<p><strong>CAT 980 and CAT 988 loaders<\/strong><\/p>\n<\/li>\n<li>\n<p><strong>CAT 350 excavators<\/strong><\/p>\n<\/li>\n<\/ul>\n<\/li>\n<li>\n<p>Support crushing operations by moving, loading, and feeding material.<\/p>\n<\/li>\n<li>\n<p>Perform basic equipment maintenance, inspections, and minor repairs to ensure reliable operation.<\/p>\n<\/li>\n<li>\n<p>Adhere to all company safety policies, site regulations, and environmental standards.<\/p>\n<\/li>\n<li>\n<p>Collaborate with team members and supervisors to achieve production targets.<\/p>\n<\/li>\n<li>\n<p>Maintain a clean, organized, and safe work area.<\/p>\n<\/li>\n<\/ul>\n<h3><strong>Qualifications<\/strong><\/h3>\n<ul>\n<li>\n<p>Proven experience operating <strong>CAT 980\/CAT 988 loaders<\/strong> and <strong>CAT 350 excavators<\/strong> in a mining or aggregate setting.<\/p>\n<\/li>\n<li>\n<p>Basic mechanical and maintenance skills, with the ability to troubleshoot and assist with minor repairs.<\/p>\n<\/li>\n<li>\n<p>Strong awareness of safety protocols and best practices in a mining environment.<\/p>\n<\/li>\n<li>\n<p>Reliable, with a <strong>team player attitude<\/strong> and willingness to pitch in wherever needed.<\/p>\n<\/li>\n<li>\n<p>Excellent communication skills and the ability to work effectively with others.<\/p>\n<\/li>\n<\/ul>\n<h3><strong>Why Join Us?<\/strong><\/h3>\n<ul>\n<li>\n<p>Competitive pay and benefits.<\/p>\n<\/li>\n<li>\n<p>Opportunity to work with an established mining operation.<\/p>\n<\/li>\n<li>\n<p>Supportive, safety-focused team environment.<\/p><\/li><\/ul>","%category%":"","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/f79c7fefd63e-heavy-equipment-operator","%breezy_id%":"f79c7fefd63e","%breezy_friendly_id%":"f79c7fefd63e-heavy-equipment-operator","%breezy_created_date%":"2025-09-09T20:07:12.544Z","%breezy_updated_date%":"2025-09-09T22:14:59.577Z","%_wpgmp_location_city%":"Wyalusing","%_wpgmp_location_state%":"PA","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Wyalusing, PA, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"41.6681309","%_wpgmp_metabox_longitude%":"-76.2618786","%rank_math_internal_links_processed%":"1"}},"id":2740,"infowindow_disable":false},{"source":"post","title":"Senior Equipment Operator","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Senior Equipment Operator\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Senior Equipment Operator &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; Reports to: Foreman \u2013 Turner Mining Group Job Description: The Senior Equipment Operator is the most&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/senior-equipment-operator\/\" name=\"Senior Equipment Operator\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Senior Equipment Operator &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; Reports to: Foreman \u2013 Turner Mining Group Job Description: The Senior Equipment Operator is the most&hellip;","address":"Soda Springs, ID, USA","location":{"lat":"42.6543652","city":"Soda Springs","state":"ID","country":"United States","lng":"-111.6046687","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/senior-equipment-operator\/","zoom":19,"extra_fields":{"post_excerpt":"Senior Equipment Operator &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; Reports to: Foreman \u2013 Turner Mining Group Job Description: The Senior Equipment Operator is the most&hellip;","post_content":"<p><strong>Senior Equipment Operator<\/strong>            &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; <\/p>\n<p><strong>Reports to: <\/strong><strong>Foreman \u2013 Turner Mining Group<\/strong><\/p>\n<p><strong>Job Description:<\/strong><\/p>\n<p>The Senior Equipment Operator is the most skilled mining operator position within Turner Mining Group. This role will oversee operational quality and efficiency as a strong field leader. The successful candidate must live the Turner Values and be an outward example to others. This position must demonstrate a strong commitment to \u201cSafe Production\u201d through decision making, priorities, and client relations.<\/p>\n<p><strong>Objectives and Contributions:<\/strong><\/p>\n<p>The Senior Equipment Operator is focused on key aspects that drive communication and safe production while maintaining a high level of efficiency, proactive training metrics, and preventative maintenance awareness requirements. The Senior Operator demonstrates safety ownership at a personal level and holds other crew members to the same high standard.&nbsp; The Senior Equipment Operator will train and develop into the Lead Equipment Operator job scope while the Lead Equipment operator is filling in for supervisory duties. <\/p>\n<ul><li>Operates mobile equipment as assigned every day based on production needs<\/li><li>Work with employees to ensure a high level of accuracy and engagement on hazard identification and control<\/li><li>Engage crews and leadership to define processes that motivate working towards common goals<\/li><li>Assist with MSHA regulatory training and verify compliance to standards<\/li><li>Live the values as part of a visible daily decision-making process<\/li><li>Assist with training efforts to grow other operators<\/li><li>Assist with training proficiency audits<\/li><li>Assist with client specific safety needs as required<\/li><li>Support risk assessment processes at various levels of the organization<\/li><li>Holds themselves and others accountable for acting like an owner (taking care of equipment, not wasting resources, using time wisely, and being accountable for conditions and behaviors)<\/li><li>Maintains a high standard of housekeeping (machine and work areas)<\/li><\/ul>\n<p><u>Culture and Communication:<\/u><\/p>\n<ul><li>Can effectively communicate in English (multi-lingual preferred)<\/li><li>Assist with daily lineout meetings and monthly safety topic communications<\/li><li>Assist with site communication programs and processes to ensure timely, specific, and value-added information<\/li><li>Assist with site and project leaders to identify areas of improvement<\/li><li>Work with crews to support proactive near miss reporting<\/li><li>Leads by example (walks the talk)<\/li><\/ul>\n<p><u>Systems:<\/u><\/p>\n<ul><li>Ability to perform quality pre-operation machine inspections (Based on mobile equipment physical demands analysis)<\/li><li>Able to perform quality workplace examination (per MSHA requirements)<\/li><li>Ability to use electronic filing and reporting systems<\/li><li>Accurately documents 5000-23 and training checklist requirements<\/li><li>Other regulatory &amp; internal \/ external forms as required<\/li><\/ul>\n<p><u>Travel and New Site Development:<\/u><\/p>\n<ul><li>Maintains a valid and insurable driving license<\/li><li>Available to travel on short notice to support timelines and production requirements at existing sites <strong>(Preferred)<\/strong><\/li><\/ul>\n<p><u>Supervisory \/ Leadership Duties<\/u><\/p>\n<ul><li>Learn and assist with key performance indicators, company targets, and daily progress reporting<\/li><li>Assist in employee timekeeping and production reports<\/li><li>Maintains compliance to Turner Mining Group Policies and Procedures including Fit for Duty requirements<\/li><li>Upholds Code of Conduct requirements<\/li><li>Spend time with maintenance, and site supervision to build relationships and develop trust<\/li><li>Assist with development \/ implement processes to reduce and eliminate repeat incidents<\/li><\/ul>\n<p><u>Time and Interactions:<\/u><\/p>\n<ul><li>The Senior Equipment Operator must be flexible on shift schedules (days and nights) to assist with training and production needs<\/li><li>The Senior Equipment Operator will be self-starting, motivated, with a strong desire to be part of a team and to influence improvement. Communication is also critical to keep leadership and site-based personnel in the loop of successes, challenges, and any additional support that may be required<\/li><li>Interacts with client supervision to discuss production challenges, targets, and collaboration between teams<\/li><li>Excellent time management skills<\/li><\/ul>\n<p><u>Qualifications:<\/u><\/p>\n<ul><li>Smart phone navigation<\/li><li>Willingness and ability to adhere to OSHA \/ MSHA regulatory requirements<\/li><li>3-5 years\u2019 experience in mining \/ heavy industry preferred<\/li><li>Working knowledge of safety systems and processes<\/li><li>Appropriate attention to detail required<\/li><li>Strong communication skills<\/li><li>Strong morals and values<\/li><li>Exemplary attendance record<\/li><li>Exemplary safety and disciplinary record<\/li><li>Willingness to be flexible on daily job duty requirements<\/li><li>Maintains a positive outspoken learning attitude<\/li><li>The Senior Equipment Operator must pass and maintain Turner Mining Group mobile equipment skills qualifications on each piece of the following equipment: <ul><li><strong>Production excavator<\/strong><\/li><li><strong><\/strong><strong>Production loader<\/strong><\/li><li><strong><\/strong><strong>Support excavator<\/strong><\/li><li><strong><\/strong><strong>Dozer<\/strong><\/li><li><strong><\/strong><strong>Support loader<\/strong><\/li><li><strong><\/strong><strong>Grader<\/strong><\/li><li><strong><\/strong><strong>Water truck,<\/strong><\/li><li><strong><\/strong><strong>Haulage truck<\/strong><\/li><\/ul><\/li><\/ul>\n<p><u>Other Duties:<\/u><\/p>\n<ul><li>In addition to the job skills above, there may be requirements for manual tasks to be completed to meet other business needs. Operators in any job duty classification may be required to participate in these additional tasks.<\/li><\/ul><p><u><strong>Benefits<\/strong><\/u><br>Turner Mining Group offers a competitive salary, an excellent work culture, and career advancement opportunities. Our team provides a benefits program which includes Medical, Dental, Vision, Life, and a 401k with company match. We believe in a work-life balance and have established paid time off for major holidays.<\/p>\n<p>At Turner Mining Group, we encourage and celebrate an inclusive environment for all employees and are proud to be an equal opportunity workplace and affirmative action employer.<\/p>\n<p><u><br><\/u><\/p>","post_title":"Senior Equipment Operator","post_link":"https:\/\/turnerstaffing.com\/position\/senior-equipment-operator\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Senior","%location_country%":"United States","%location_city%":"Soda Springs","%location_state_id%":"ID","%location_state_name%":"Idaho","%location_city_state%":"Soda Springs, ID","%education%":"Unspecified","%department%":"Operations","%description%":"<p><strong>Senior Equipment Operator<\/strong>            &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; <\/p>\n<p><strong>Reports to: <\/strong><strong>Foreman \u2013 Turner Mining Group<\/strong><\/p>\n<p><strong>Job Description:<\/strong><\/p>\n<p>The Senior Equipment Operator is the most skilled mining operator position within Turner Mining Group. This role will oversee operational quality and efficiency as a strong field leader. The successful candidate must live the Turner Values and be an outward example to others. This position must demonstrate a strong commitment to \u201cSafe Production\u201d through decision making, priorities, and client relations.<\/p>\n<p><strong>Objectives and Contributions:<\/strong><\/p>\n<p>The Senior Equipment Operator is focused on key aspects that drive communication and safe production while maintaining a high level of efficiency, proactive training metrics, and preventative maintenance awareness requirements. The Senior Operator demonstrates safety ownership at a personal level and holds other crew members to the same high standard.&nbsp; The Senior Equipment Operator will train and develop into the Lead Equipment Operator job scope while the Lead Equipment operator is filling in for supervisory duties. <\/p>\n<ul><li>Operates mobile equipment as assigned every day based on production needs<\/li><li>Work with employees to ensure a high level of accuracy and engagement on hazard identification and control<\/li><li>Engage crews and leadership to define processes that motivate working towards common goals<\/li><li>Assist with MSHA regulatory training and verify compliance to standards<\/li><li>Live the values as part of a visible daily decision-making process<\/li><li>Assist with training efforts to grow other operators<\/li><li>Assist with training proficiency audits<\/li><li>Assist with client specific safety needs as required<\/li><li>Support risk assessment processes at various levels of the organization<\/li><li>Holds themselves and others accountable for acting like an owner (taking care of equipment, not wasting resources, using time wisely, and being accountable for conditions and behaviors)<\/li><li>Maintains a high standard of housekeeping (machine and work areas)<\/li><\/ul>\n<p><u>Culture and Communication:<\/u><\/p>\n<ul><li>Can effectively communicate in English (multi-lingual preferred)<\/li><li>Assist with daily lineout meetings and monthly safety topic communications<\/li><li>Assist with site communication programs and processes to ensure timely, specific, and value-added information<\/li><li>Assist with site and project leaders to identify areas of improvement<\/li><li>Work with crews to support proactive near miss reporting<\/li><li>Leads by example (walks the talk)<\/li><\/ul>\n<p><u>Systems:<\/u><\/p>\n<ul><li>Ability to perform quality pre-operation machine inspections (Based on mobile equipment physical demands analysis)<\/li><li>Able to perform quality workplace examination (per MSHA requirements)<\/li><li>Ability to use electronic filing and reporting systems<\/li><li>Accurately documents 5000-23 and training checklist requirements<\/li><li>Other regulatory &amp; internal \/ external forms as required<\/li><\/ul>\n<p><u>Travel and New Site Development:<\/u><\/p>\n<ul><li>Maintains a valid and insurable driving license<\/li><li>Available to travel on short notice to support timelines and production requirements at existing sites <strong>(Preferred)<\/strong><\/li><\/ul>\n<p><u>Supervisory \/ Leadership Duties<\/u><\/p>\n<ul><li>Learn and assist with key performance indicators, company targets, and daily progress reporting<\/li><li>Assist in employee timekeeping and production reports<\/li><li>Maintains compliance to Turner Mining Group Policies and Procedures including Fit for Duty requirements<\/li><li>Upholds Code of Conduct requirements<\/li><li>Spend time with maintenance, and site supervision to build relationships and develop trust<\/li><li>Assist with development \/ implement processes to reduce and eliminate repeat incidents<\/li><\/ul>\n<p><u>Time and Interactions:<\/u><\/p>\n<ul><li>The Senior Equipment Operator must be flexible on shift schedules (days and nights) to assist with training and production needs<\/li><li>The Senior Equipment Operator will be self-starting, motivated, with a strong desire to be part of a team and to influence improvement. Communication is also critical to keep leadership and site-based personnel in the loop of successes, challenges, and any additional support that may be required<\/li><li>Interacts with client supervision to discuss production challenges, targets, and collaboration between teams<\/li><li>Excellent time management skills<\/li><\/ul>\n<p><u>Qualifications:<\/u><\/p>\n<ul><li>Smart phone navigation<\/li><li>Willingness and ability to adhere to OSHA \/ MSHA regulatory requirements<\/li><li>3-5 years\u2019 experience in mining \/ heavy industry preferred<\/li><li>Working knowledge of safety systems and processes<\/li><li>Appropriate attention to detail required<\/li><li>Strong communication skills<\/li><li>Strong morals and values<\/li><li>Exemplary attendance record<\/li><li>Exemplary safety and disciplinary record<\/li><li>Willingness to be flexible on daily job duty requirements<\/li><li>Maintains a positive outspoken learning attitude<\/li><li>The Senior Equipment Operator must pass and maintain Turner Mining Group mobile equipment skills qualifications on each piece of the following equipment: <ul><li><strong>Production excavator<\/strong><\/li><li><strong><\/strong><strong>Production loader<\/strong><\/li><li><strong><\/strong><strong>Support excavator<\/strong><\/li><li><strong><\/strong><strong>Dozer<\/strong><\/li><li><strong><\/strong><strong>Support loader<\/strong><\/li><li><strong><\/strong><strong>Grader<\/strong><\/li><li><strong><\/strong><strong>Water truck,<\/strong><\/li><li><strong><\/strong><strong>Haulage truck<\/strong><\/li><\/ul><\/li><\/ul>\n<p><u>Other Duties:<\/u><\/p>\n<ul><li>In addition to the job skills above, there may be requirements for manual tasks to be completed to meet other business needs. Operators in any job duty classification may be required to participate in these additional tasks.<\/li><\/ul><p><u><strong>Benefits<\/strong><\/u><br>Turner Mining Group offers a competitive salary, an excellent work culture, and career advancement opportunities. Our team provides a benefits program which includes Medical, Dental, Vision, Life, and a 401k with company match. We believe in a work-life balance and have established paid time off for major holidays.<\/p>\n<p>At Turner Mining Group, we encourage and celebrate an inclusive environment for all employees and are proud to be an equal opportunity workplace and affirmative action employer.<\/p>\n<p><u><br><\/u><\/p>","%category%":"Operations","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/1a4e91ed9235-senior-equipment-operator","%breezy_id%":"1a4e91ed9235","%breezy_friendly_id%":"1a4e91ed9235-senior-equipment-operator","%breezy_created_date%":"2025-09-04T23:03:03.926Z","%breezy_updated_date%":"2025-09-16T14:55:06.287Z","%_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":2737,"infowindow_disable":false},{"source":"post","title":"Lead Equipment Operator","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Lead Equipment Operator\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Lead Equipment Operator &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; Reports to: Foreman \u2013 Turner Mining Group Job Description: The Lead Equipment Operator is the most&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/lead-equipment-operator\/\" name=\"Lead Equipment Operator\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Lead Equipment Operator &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; Reports to: Foreman \u2013 Turner Mining Group Job Description: The Lead Equipment Operator is the most&hellip;","address":"Soda Springs, ID, USA","location":{"lat":"42.6543652","city":"Soda Springs","state":"ID","country":"United States","lng":"-111.6046687","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/lead-equipment-operator\/","zoom":19,"extra_fields":{"post_excerpt":"Lead Equipment Operator &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; Reports to: Foreman \u2013 Turner Mining Group Job Description: The Lead Equipment Operator is the most&hellip;","post_content":"<p><strong>Lead Equipment Operator<\/strong>        &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; <\/p>\n<p><strong>Reports to: <\/strong><strong>Foreman \u2013 Turner Mining Group<\/strong><\/p>\n<p><strong>Job Description:<\/strong><\/p>\n<p>The Lead Equipment Operator is the most skilled mining operator position with a focus on developing supervisory leadership within Turner Mining Group. This position will also assist with training other crew members as an SME (Subject Matter Expert), assisting with supervisory duties as a fill-in for the Foreman (as needed), and will oversee operational quality and efficiency as a strong field leader. The successful candidate must live the Turner Values and be an outward example to others. This position must demonstrate a strong commitment to \u201cSafe Production\u201d through decision making, priorities, and client relations.<\/p>\n<p><strong>Objectives and Contributions:<\/strong><\/p>\n<p>The Lead Equipment Operator is focused on key aspects that drive communication and safe production while maintaining a high level of efficiency, proactive training metrics, and preventative maintenance awareness requirements. The Lead Equipment Operator demonstrates safety ownership at a personal level and holds other crew members to the same high standard.&nbsp; The Lead Equipment Operator also assists in other production support functions as assigned.<\/p>\n<ul><li>Operates mobile equipment as assigned every day based on production needs<\/li><li>Work with employees to ensure a high level of accuracy and engagement on hazard identification and control<\/li><li>Engage crews and leadership to define processes that motivate working towards common goals<\/li><li>Assist with MSHA regulatory training and verify compliance to standards<\/li><li>Live the values as part of a visible daily decision-making process<\/li><li>Audit the crew and the site while focusing on conditions and behaviors that reflect our desire to be the best in the business<\/li><li>Lead training efforts to grow other operators<\/li><li>Assist with training proficiency audits<\/li><li>Assist with client specific safety needs as required<\/li><li>Support risk assessment processes at various levels of the organization<\/li><li>Holds themselves and others accountable for acting like an owner (taking care of equipment, not wasting resources, using time wisely, and being accountable for conditions and behaviors)<\/li><li>Maintains a high standard of housekeeping (machine and work areas)<\/li><\/ul>\n<p><u>Culture and Communication:<\/u><\/p>\n<ul><li>Can effectively communicate in English (multi-lingual preferred)<\/li><li>Assist with daily lineout meetings and monthly safety topic communications<\/li><li>Assist with site communication programs and processes to ensure timely, specific, and value-added information<\/li><li>Assist with site and project leaders to identify areas of improvement<\/li><li>Work with crews to support proactive near miss reporting<\/li><li>Leads by example (walks the talk)<\/li><\/ul>\n<p><u>Systems:<\/u><\/p>\n<ul><li>Ability to perform quality pre-operation machine inspections<\/li><li>Able to perform quality workplace examination (Per MSHA requirements)<\/li><li>Ability to use electronic filing and reporting systems<\/li><li>Accurately documents 5000-23 and training checklist requirements<\/li><li>Other regulatory &amp; internal \/ external forms as required<\/li><\/ul>\n<p><u>Travel and New Site Development: <\/u><\/p>\n<ul><li>Maintains a valid and insurable driving license<\/li><li>Available to travel on short notice for new site development activities <strong>(Preferred)<\/strong><\/li><li>Available to travel on short notice to support timelines and production requirements at existing sites <strong>(Preferred)<\/strong><\/li><li>Leads new site start-up activities and development of safety tools<\/li><\/ul>\n<p><u>Supervisory \/ Leadership Duties:<\/u><\/p>\n<ul><li>Work directly with site leadership to ensure consistent use of systems, programs, and processes<\/li><li>Assist with crew progression and employee development<\/li><li>Learn and assist with key performance indicators, company targets, and daily progress reporting<\/li><li>Assist in employee timekeeping and production reports<\/li><li>Maintains compliance to Turner Mining Group Policies and Procedures including Fit for Duty requirements<\/li><li>Upholds Code of Conduct requirements<\/li><li>Spend time with Maintenance, and site supervision to build relationships and develop trust<\/li><li>Assist with development \/ implement processes to reduce and eliminate repeat incidents<\/li><li>Assist in problem-solving including incident investigations, root cause analysis, and corrective action development<\/li><li>Assist in managing maintenance notifications (identification and follow up)<\/li><li>Ability to use site management software <\/li><\/ul>\n<p><u>Time and Interactions:<\/u><\/p>\n<ul><li>The Lead Equipment Operator must be flexible on shift schedules (days and nights) to assist with training and production needs<\/li><li>The Lead Equipment Operator will be self-starting, motivated, with a strong desire to be part of a team and to influence improvement. Communication is also critical to keep leadership and site-based personnel in the loop of successes, challenges, and any additional support that may be required<\/li><li>Interacts with client supervision to discuss production challenges, targets, and collaboration between teams<\/li><li>Excellent time management skills<\/li><\/ul>\n<p><u>Qualifications:<\/u><\/p>\n<ul><li>Microsoft Office proficiency <\/li><li>Willingness and ability to adhere to OSHA \/ MSHA regulatory requirements<\/li><li>5-10 years\u2019 experience in mining \/ heavy industry preferred<\/li><li>Working knowledge of safety systems and processes<\/li><li>Appropriate attention to detail required<\/li><li>Strong communication skills<\/li><li>Strong morals and values<\/li><li>Exemplary attendance record<\/li><li>Exemplary safety and disciplinary record<\/li><li>Willingness to be flexible on daily job duty requirements<\/li><li>Maintains a positive outspoken learning attitude<\/li><li>The Lead Equipment Operator must pass and maintain Turner Mining Group mobile equipment skills qualifications on each piece of the following equipment:<ul><li><strong>Production excavator,<\/strong><\/li><li><strong>Production loader, <\/strong><\/li><li><strong>Support excavator,<\/strong><\/li><li><strong>Dozer,<\/strong><\/li><li><strong>Support loader, <\/strong><\/li><li><strong>Grader,<\/strong><\/li><li><strong>Water truck, <\/strong><\/li><li><strong>Haulage truck<\/strong><\/li><\/ul><\/li><\/ul>\n<p><u>Other Duties:<\/u><\/p>\n<ul><li>In addition to the job skills above, there may be requirements for manual tasks to be completed to meet other business needs. Operators in any job duty classification may be required to participate in these additional tasks.<\/li><\/ul><p><u><strong>Benefits<\/strong><\/u><br>Turner Mining Group offers a competitive salary, an excellent work culture, and career advancement opportunities. Our team provides a benefits program which includes Medical, Dental, Vision, Life, and a 401k with company match. We believe in a work-life balance and have established paid time off for major holidays.<\/p>\n<p>At Turner Mining Group, we encourage and celebrate an inclusive environment for all employees and are proud to be an equal opportunity workplace and affirmative action employer.<\/p>\n<p><u><br><\/u><\/p>","post_title":"Lead Equipment Operator","post_link":"https:\/\/turnerstaffing.com\/position\/lead-equipment-operator\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Senior","%location_country%":"United States","%location_city%":"Soda Springs","%location_state_id%":"ID","%location_state_name%":"Idaho","%location_city_state%":"Soda Springs, ID","%education%":"Unspecified","%department%":"Operations","%description%":"<p><strong>Lead Equipment Operator<\/strong>        &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; <\/p>\n<p><strong>Reports to: <\/strong><strong>Foreman \u2013 Turner Mining Group<\/strong><\/p>\n<p><strong>Job Description:<\/strong><\/p>\n<p>The Lead Equipment Operator is the most skilled mining operator position with a focus on developing supervisory leadership within Turner Mining Group. This position will also assist with training other crew members as an SME (Subject Matter Expert), assisting with supervisory duties as a fill-in for the Foreman (as needed), and will oversee operational quality and efficiency as a strong field leader. The successful candidate must live the Turner Values and be an outward example to others. This position must demonstrate a strong commitment to \u201cSafe Production\u201d through decision making, priorities, and client relations.<\/p>\n<p><strong>Objectives and Contributions:<\/strong><\/p>\n<p>The Lead Equipment Operator is focused on key aspects that drive communication and safe production while maintaining a high level of efficiency, proactive training metrics, and preventative maintenance awareness requirements. The Lead Equipment Operator demonstrates safety ownership at a personal level and holds other crew members to the same high standard.&nbsp; The Lead Equipment Operator also assists in other production support functions as assigned.<\/p>\n<ul><li>Operates mobile equipment as assigned every day based on production needs<\/li><li>Work with employees to ensure a high level of accuracy and engagement on hazard identification and control<\/li><li>Engage crews and leadership to define processes that motivate working towards common goals<\/li><li>Assist with MSHA regulatory training and verify compliance to standards<\/li><li>Live the values as part of a visible daily decision-making process<\/li><li>Audit the crew and the site while focusing on conditions and behaviors that reflect our desire to be the best in the business<\/li><li>Lead training efforts to grow other operators<\/li><li>Assist with training proficiency audits<\/li><li>Assist with client specific safety needs as required<\/li><li>Support risk assessment processes at various levels of the organization<\/li><li>Holds themselves and others accountable for acting like an owner (taking care of equipment, not wasting resources, using time wisely, and being accountable for conditions and behaviors)<\/li><li>Maintains a high standard of housekeeping (machine and work areas)<\/li><\/ul>\n<p><u>Culture and Communication:<\/u><\/p>\n<ul><li>Can effectively communicate in English (multi-lingual preferred)<\/li><li>Assist with daily lineout meetings and monthly safety topic communications<\/li><li>Assist with site communication programs and processes to ensure timely, specific, and value-added information<\/li><li>Assist with site and project leaders to identify areas of improvement<\/li><li>Work with crews to support proactive near miss reporting<\/li><li>Leads by example (walks the talk)<\/li><\/ul>\n<p><u>Systems:<\/u><\/p>\n<ul><li>Ability to perform quality pre-operation machine inspections<\/li><li>Able to perform quality workplace examination (Per MSHA requirements)<\/li><li>Ability to use electronic filing and reporting systems<\/li><li>Accurately documents 5000-23 and training checklist requirements<\/li><li>Other regulatory &amp; internal \/ external forms as required<\/li><\/ul>\n<p><u>Travel and New Site Development: <\/u><\/p>\n<ul><li>Maintains a valid and insurable driving license<\/li><li>Available to travel on short notice for new site development activities <strong>(Preferred)<\/strong><\/li><li>Available to travel on short notice to support timelines and production requirements at existing sites <strong>(Preferred)<\/strong><\/li><li>Leads new site start-up activities and development of safety tools<\/li><\/ul>\n<p><u>Supervisory \/ Leadership Duties:<\/u><\/p>\n<ul><li>Work directly with site leadership to ensure consistent use of systems, programs, and processes<\/li><li>Assist with crew progression and employee development<\/li><li>Learn and assist with key performance indicators, company targets, and daily progress reporting<\/li><li>Assist in employee timekeeping and production reports<\/li><li>Maintains compliance to Turner Mining Group Policies and Procedures including Fit for Duty requirements<\/li><li>Upholds Code of Conduct requirements<\/li><li>Spend time with Maintenance, and site supervision to build relationships and develop trust<\/li><li>Assist with development \/ implement processes to reduce and eliminate repeat incidents<\/li><li>Assist in problem-solving including incident investigations, root cause analysis, and corrective action development<\/li><li>Assist in managing maintenance notifications (identification and follow up)<\/li><li>Ability to use site management software <\/li><\/ul>\n<p><u>Time and Interactions:<\/u><\/p>\n<ul><li>The Lead Equipment Operator must be flexible on shift schedules (days and nights) to assist with training and production needs<\/li><li>The Lead Equipment Operator will be self-starting, motivated, with a strong desire to be part of a team and to influence improvement. Communication is also critical to keep leadership and site-based personnel in the loop of successes, challenges, and any additional support that may be required<\/li><li>Interacts with client supervision to discuss production challenges, targets, and collaboration between teams<\/li><li>Excellent time management skills<\/li><\/ul>\n<p><u>Qualifications:<\/u><\/p>\n<ul><li>Microsoft Office proficiency <\/li><li>Willingness and ability to adhere to OSHA \/ MSHA regulatory requirements<\/li><li>5-10 years\u2019 experience in mining \/ heavy industry preferred<\/li><li>Working knowledge of safety systems and processes<\/li><li>Appropriate attention to detail required<\/li><li>Strong communication skills<\/li><li>Strong morals and values<\/li><li>Exemplary attendance record<\/li><li>Exemplary safety and disciplinary record<\/li><li>Willingness to be flexible on daily job duty requirements<\/li><li>Maintains a positive outspoken learning attitude<\/li><li>The Lead Equipment Operator must pass and maintain Turner Mining Group mobile equipment skills qualifications on each piece of the following equipment:<ul><li><strong>Production excavator,<\/strong><\/li><li><strong>Production loader, <\/strong><\/li><li><strong>Support excavator,<\/strong><\/li><li><strong>Dozer,<\/strong><\/li><li><strong>Support loader, <\/strong><\/li><li><strong>Grader,<\/strong><\/li><li><strong>Water truck, <\/strong><\/li><li><strong>Haulage truck<\/strong><\/li><\/ul><\/li><\/ul>\n<p><u>Other Duties:<\/u><\/p>\n<ul><li>In addition to the job skills above, there may be requirements for manual tasks to be completed to meet other business needs. Operators in any job duty classification may be required to participate in these additional tasks.<\/li><\/ul><p><u><strong>Benefits<\/strong><\/u><br>Turner Mining Group offers a competitive salary, an excellent work culture, and career advancement opportunities. Our team provides a benefits program which includes Medical, Dental, Vision, Life, and a 401k with company match. We believe in a work-life balance and have established paid time off for major holidays.<\/p>\n<p>At Turner Mining Group, we encourage and celebrate an inclusive environment for all employees and are proud to be an equal opportunity workplace and affirmative action employer.<\/p>\n<p><u><br><\/u><\/p>","%category%":"Operations","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/bd09e64885df-lead-equipment-operator","%breezy_id%":"bd09e64885df","%breezy_friendly_id%":"bd09e64885df-lead-equipment-operator","%breezy_created_date%":"2025-09-09T15:38:44.592Z","%breezy_updated_date%":"2025-09-16T14:54:22.348Z","%_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":2738,"infowindow_disable":false},{"source":"post","title":"Fuel\/Lube Technician","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Fuel\/Lube Technician\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Fuel \/ Lube Technician &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; Reports to: Foreman \u2013 Turner Mining Group Job Description: The Fuel \/ Lube Technician is&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/fuel-lube-technician\/\" name=\"Fuel\/Lube Technician\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Fuel \/ Lube Technician &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; Reports to: Foreman \u2013 Turner Mining Group Job Description: The Fuel \/ Lube Technician is&hellip;","address":"Soda Springs, ID, USA","location":{"lat":"42.6543652","city":"Soda Springs","state":"ID","country":"United States","lng":"-111.6046687","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/fuel-lube-technician\/","zoom":19,"extra_fields":{"post_excerpt":"Fuel \/ Lube Technician &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; Reports to: Foreman \u2013 Turner Mining Group Job Description: The Fuel \/ Lube Technician is&hellip;","post_content":"<p><strong>Fuel \/ Lube Technician<\/strong>            &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; <\/p>\n<p><strong>Reports to: <\/strong><strong>Foreman \u2013 Turner Mining Group<\/strong><\/p>\n<p><strong>Job Description:<\/strong><\/p>\n<p>The Fuel \/ Lube Technician is a developing Maintenance Technician role within Turner Mining Group. This role will be focused on maintaining equipment. The successful candidate must live the Turner Values and be an outward example to others. This position must demonstrate a strong commitment to \u201cSafe Production\u201d through decision making, priorities, and client relations.<\/p>\n<p><strong>Objectives and Contributions:<\/strong><\/p>\n<p>The Fuel \/ Lube Technician is focused on key aspects that drive communication and safe production while maintaining a high level of efficiency, proactive training metrics, and preventative maintenance awareness requirements. The Fuel \/ Lube Technician demonstrates safety ownership at a personal level and holds other crew members to the same high standard.&nbsp; The Fuel \/ Lube Technician also assists in other production support functions as assigned.<\/p>\n<ul><li>Work with employees to ensure a high level of accuracy and engagement on hazard identification and control<\/li><li>Engage crews and leadership to define processes that motivate working towards common goals<\/li><li>Assist with MSHA regulatory training and verify compliance to standards<\/li><li>Live the values as part of a visible daily decision-making process<\/li><li>Assist with training proficiency audits<\/li><li>Involvement in risk assessment processes at various levels of the organization<\/li><li>Holds themselves and others accountable for acting like an owner (taking care of equipment, not wasting resources, using time wisely, and being accountable for conditions and behaviors)<\/li><li>Maintains a high standard of housekeeping (machine and work areas)<\/li><\/ul>\n<p><u>Culture and Communication:<\/u><\/p>\n<ul><li>Can effectively communicate in English (multi-lingual preferred)<\/li><li>Participate with site and project leaders to identify areas of improvement<\/li><li>Work with crews to support proactive near miss reporting<\/li><li>Leads by example (walks the talk)<\/li><\/ul>\n<p><u>Systems:<\/u><\/p>\n<ul><li>Ability to perform quality pre-operation machine inspections (Based on mobile equipment physical demands analysis)<\/li><li>Accurately documents 5000-23 and training checklist requirements<\/li><li>Other regulatory &amp; internal \/ external forms as required<\/li><li>Maintains a valid and insurable driving license<\/li><\/ul>\n<p><u>Travel and New Site Development: <\/u><\/p>\n<p><u>Time and Interactions:<\/u><\/p>\n<ul><li>The Fuel \/ Lube Technician must be flexible on shift schedules (days and nights) to assist with training and production needs<\/li><li>The Fuel \/ Lube Technician will be self-starting, motivated, with a strong desire to be part of a team and to influence improvement. Communication is also critical to keep leadership and site-based personnel in the loop of successes, challenges, and any additional support that may be required<\/li><li>Excellent time management skills<\/li><\/ul>\n<p><u>Qualifications:<\/u><\/p>\n<ul><li>Willingness and ability to adhere to OSHA \/ MSHA regulatory requirements<\/li><li>0-2 years\u2019 experience in mining \/ heavy industry preferred<\/li><li>Working knowledge of safety systems and processes<\/li><li>Appropriate attention to detail required<\/li><li>Strong communication skills<\/li><li>Strong morals and values<\/li><li>Exemplary attendance record<\/li><li>Exemplary safety and disciplinary record<\/li><li>Willingness to be flexible on daily job duty requirements<\/li><li>Maintains a positive outspoken learning attitude<\/li><li>The Fuel \/ Lube Technician must be able to safely perform each of the following tasks: <ul><li><strong>Fuel \/ lube Truck<\/strong><\/li><li><strong><\/strong><strong>Fueling \/ lubing equipment<\/strong><\/li><li><strong><\/strong><strong>Equipment fluid level monitoring<\/strong><\/li><li><strong><\/strong><strong>Marshalling equipment<\/strong><\/li><li><strong><\/strong><strong>Washing equipment<\/strong><\/li><\/ul><\/li><\/ul>\n<p><u>Other Duties:<\/u><\/p>\n<ul><li>In addition to the job skills above, there may be requirements for manual tasks to be completed to meet other business needs. Operators in any job duty classification may be required to participate in these additional tasks.<\/li><\/ul><p><u><strong>Benefits<\/strong><\/u><br>Turner Mining Group offers a competitive salary, an excellent work culture, and career advancement opportunities. Our team provides a benefits program which includes Medical, Dental, Vision, Life, and a 401k with company match. We believe in a work-life balance and have established paid time off for major holidays.<\/p>\n<p>At Turner Mining Group, we encourage and celebrate an inclusive environment for all employees and are proud to be an equal opportunity workplace and affirmative action employer.<\/p>","post_title":"Fuel\/Lube Technician","post_link":"https:\/\/turnerstaffing.com\/position\/fuel-lube-technician\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Entry Level","%location_country%":"United States","%location_city%":"Soda Springs","%location_state_id%":"ID","%location_state_name%":"Idaho","%location_city_state%":"Soda Springs, ID","%education%":"Unspecified","%department%":"Maintenance","%description%":"<p><strong>Fuel \/ Lube Technician<\/strong>            &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; <\/p>\n<p><strong>Reports to: <\/strong><strong>Foreman \u2013 Turner Mining Group<\/strong><\/p>\n<p><strong>Job Description:<\/strong><\/p>\n<p>The Fuel \/ Lube Technician is a developing Maintenance Technician role within Turner Mining Group. This role will be focused on maintaining equipment. The successful candidate must live the Turner Values and be an outward example to others. This position must demonstrate a strong commitment to \u201cSafe Production\u201d through decision making, priorities, and client relations.<\/p>\n<p><strong>Objectives and Contributions:<\/strong><\/p>\n<p>The Fuel \/ Lube Technician is focused on key aspects that drive communication and safe production while maintaining a high level of efficiency, proactive training metrics, and preventative maintenance awareness requirements. The Fuel \/ Lube Technician demonstrates safety ownership at a personal level and holds other crew members to the same high standard.&nbsp; The Fuel \/ Lube Technician also assists in other production support functions as assigned.<\/p>\n<ul><li>Work with employees to ensure a high level of accuracy and engagement on hazard identification and control<\/li><li>Engage crews and leadership to define processes that motivate working towards common goals<\/li><li>Assist with MSHA regulatory training and verify compliance to standards<\/li><li>Live the values as part of a visible daily decision-making process<\/li><li>Assist with training proficiency audits<\/li><li>Involvement in risk assessment processes at various levels of the organization<\/li><li>Holds themselves and others accountable for acting like an owner (taking care of equipment, not wasting resources, using time wisely, and being accountable for conditions and behaviors)<\/li><li>Maintains a high standard of housekeeping (machine and work areas)<\/li><\/ul>\n<p><u>Culture and Communication:<\/u><\/p>\n<ul><li>Can effectively communicate in English (multi-lingual preferred)<\/li><li>Participate with site and project leaders to identify areas of improvement<\/li><li>Work with crews to support proactive near miss reporting<\/li><li>Leads by example (walks the talk)<\/li><\/ul>\n<p><u>Systems:<\/u><\/p>\n<ul><li>Ability to perform quality pre-operation machine inspections (Based on mobile equipment physical demands analysis)<\/li><li>Accurately documents 5000-23 and training checklist requirements<\/li><li>Other regulatory &amp; internal \/ external forms as required<\/li><li>Maintains a valid and insurable driving license<\/li><\/ul>\n<p><u>Travel and New Site Development: <\/u><\/p>\n<p><u>Time and Interactions:<\/u><\/p>\n<ul><li>The Fuel \/ Lube Technician must be flexible on shift schedules (days and nights) to assist with training and production needs<\/li><li>The Fuel \/ Lube Technician will be self-starting, motivated, with a strong desire to be part of a team and to influence improvement. Communication is also critical to keep leadership and site-based personnel in the loop of successes, challenges, and any additional support that may be required<\/li><li>Excellent time management skills<\/li><\/ul>\n<p><u>Qualifications:<\/u><\/p>\n<ul><li>Willingness and ability to adhere to OSHA \/ MSHA regulatory requirements<\/li><li>0-2 years\u2019 experience in mining \/ heavy industry preferred<\/li><li>Working knowledge of safety systems and processes<\/li><li>Appropriate attention to detail required<\/li><li>Strong communication skills<\/li><li>Strong morals and values<\/li><li>Exemplary attendance record<\/li><li>Exemplary safety and disciplinary record<\/li><li>Willingness to be flexible on daily job duty requirements<\/li><li>Maintains a positive outspoken learning attitude<\/li><li>The Fuel \/ Lube Technician must be able to safely perform each of the following tasks: <ul><li><strong>Fuel \/ lube Truck<\/strong><\/li><li><strong><\/strong><strong>Fueling \/ lubing equipment<\/strong><\/li><li><strong><\/strong><strong>Equipment fluid level monitoring<\/strong><\/li><li><strong><\/strong><strong>Marshalling equipment<\/strong><\/li><li><strong><\/strong><strong>Washing equipment<\/strong><\/li><\/ul><\/li><\/ul>\n<p><u>Other Duties:<\/u><\/p>\n<ul><li>In addition to the job skills above, there may be requirements for manual tasks to be completed to meet other business needs. Operators in any job duty classification may be required to participate in these additional tasks.<\/li><\/ul><p><u><strong>Benefits<\/strong><\/u><br>Turner Mining Group offers a competitive salary, an excellent work culture, and career advancement opportunities. Our team provides a benefits program which includes Medical, Dental, Vision, Life, and a 401k with company match. We believe in a work-life balance and have established paid time off for major holidays.<\/p>\n<p>At Turner Mining Group, we encourage and celebrate an inclusive environment for all employees and are proud to be an equal opportunity workplace and affirmative action employer.<\/p>","%category%":"Other","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/b9d9a508a1d7-fuel-lube-technician","%breezy_id%":"b9d9a508a1d7","%breezy_friendly_id%":"b9d9a508a1d7-fuel-lube-technician","%breezy_created_date%":"2025-09-04T22:52:11.360Z","%breezy_updated_date%":"2025-09-16T14:53:37.513Z","%_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":2735,"infowindow_disable":false},{"source":"post","title":"Maintenance Technician","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Maintenance Technician\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Maintenance Technician &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; Reports to: Foreman \u2013 Turner Mining Group Job Description: The Maintenance Technician is a skilled mining maintenance&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/maintenance-technician\/\" name=\"Maintenance Technician\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Maintenance Technician &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; Reports to: Foreman \u2013 Turner Mining Group Job Description: The Maintenance Technician is a skilled mining maintenance&hellip;","address":"Soda Springs, ID, USA","location":{"lat":"42.6543652","city":"Soda Springs","state":"ID","country":"United States","lng":"-111.6046687","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/maintenance-technician\/","zoom":19,"extra_fields":{"post_excerpt":"Maintenance Technician &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; Reports to: Foreman \u2013 Turner Mining Group Job Description: The Maintenance Technician is a skilled mining maintenance&hellip;","post_content":"<p><strong>Maintenance Technician<\/strong>            &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; <\/p>\n<p><strong>Reports to: <\/strong><strong>Foreman \u2013 Turner Mining Group<\/strong><\/p>\n<p><strong>Job Description:<\/strong><\/p>\n<p>The Maintenance Technician is a skilled mining maintenance position within Turner Mining Group. This position will focus on maintaining equipment. The successful candidate must live the Turner Values and be an outward example to others. This position must demonstrate a strong commitment to \u201cSafe Production\u201d through decision making, priorities, and client relations.<\/p>\n<p><strong>Objectives and Contributions:<\/strong><\/p>\n<p>The Maintenance Technician is focused on key aspects that drive communication and safe production while maintaining a high level of efficiency, proactive training metrics, and preventative maintenance awareness requirements. The Maintenance Technician demonstrates safety ownership at a personal level and holds other crew members to the same high standard.&nbsp; The Maintenance Technician also assists in other production support functions as assigned.<\/p>\n<ul><li>Work with employees to ensure a high level of accuracy and engagement on hazard identification and control<\/li><li>Engage crews and leadership to define processes that motivate working towards common goals<\/li><li>Assist with MSHA regulatory training and verify compliance to standards<\/li><li>Live the values as part of a visible daily decision-making process<\/li><li>Assist with training proficiency audits<\/li><li>Involvement in risk assessment processes at various levels of the organization<\/li><li>Holds themselves and others accountable for acting like an owner (taking care of equipment, not wasting resources, using time wisely, and being accountable for conditions and behaviors)<\/li><li>Maintains a high standard of housekeeping (machine and work areas)<\/li><\/ul>\n<p><u>Culture and Communication:<\/u><\/p>\n<ul><li>Can effectively communicate in English (multi-lingual preferred)<\/li><li>Participate with site and project leaders to identify areas of improvement<\/li><li>Work with crews to support proactive near miss reporting<\/li><li>Leads by example (walks the talk)<\/li><\/ul>\n<p><u>Systems:<\/u><\/p>\n<ul><li>Ability to perform quality pre-operation machine inspections (Based on mobile equipment physical demands analysis)<\/li><li>Accurately documents 5000-23 and training checklist requirements<\/li><li>Other regulatory &amp; internal \/ external forms as required<\/li><\/ul>\n<p><u>Travel and New Site Development: <\/u><\/p>\n<ul><li>Maintains a valid and insurable driving license<\/li><li>Available to travel on short notice to support timelines and production requirements at existing sites <strong>(Preferred)<\/strong><\/li><\/ul>\n<p><u>Time and Interactions:<\/u><\/p>\n<ul><li>The Maintenance Technician must be flexible on shift schedules (days and nights) to assist with training and production needs<\/li><li>The Maintenance Technician will be self-starting, motivated, with a strong desire to be part of a team and to influence improvement. Communication is also critical to keep leadership and site-based personnel in the loop of successes, challenges, and any additional support that may be required<\/li><li>Excellent time management skills<\/li><\/ul>\n<p><u>Qualifications:<\/u><\/p>\n<ul><li>Willingness and ability to adhere to OSHA \/ MSHA regulatory requirements<\/li><li>1-3 years\u2019 experience in mining \/ heavy industry preferred<\/li><li>Working knowledge of safety systems and processes<\/li><li>Appropriate attention to detail required<\/li><li>Strong communication skills<\/li><li>Strong morals and values<\/li><li>Exemplary attendance record<\/li><li>Exemplary safety and disciplinary record<\/li><li>Willingness to be flexible on daily job duty requirements<\/li><li>Maintains a positive outspoken learning attitude<\/li><li>The Maintenance Technician must be able to safely perform each of the following tasks: <ul><li><strong>Maintenance service truck<\/strong><\/li><li><strong><\/strong><strong>G.E.T replacement<\/strong><\/li><li><strong><\/strong><strong>Replacing equipment attachments<\/strong><\/li><li><strong><\/strong><strong>Minor equipment repairs<\/strong><\/li><li><strong><\/strong><strong>Preventative maintenance backlog repairs<\/strong><\/li><li><strong><\/strong><strong>Fuel \/ lube Truck<\/strong><\/li><li><strong><\/strong><strong>Fueling \/ lubing equipment<\/strong><\/li><li><strong><\/strong><strong>Equipment fluid level monitoring<\/strong><\/li><li><strong><\/strong><strong>Marshalling equipment<\/strong><\/li><li><strong><\/strong><strong>Washing equipment<\/strong><\/li><\/ul><\/li><\/ul>\n<p><u>Other Duties:<\/u><\/p>\n<ul><li>In addition to the job skills above, there may be requirements for manual tasks to be completed to meet other business needs. Operators in any job duty classification may be required to participate in these additional tasks.<u><\/u><\/li><\/ul><p><u><strong>Benefits<\/strong><\/u><br>Turner Mining Group offers a competitive salary, an excellent work culture, and career advancement opportunities. Our team provides a benefits program which includes Medical, Dental, Vision, Life, and a 401k with company match. We believe in a work-life balance and have established paid time off for major holidays.<\/p>\n<p>At Turner Mining Group, we encourage and celebrate an inclusive environment for all employees and are proud to be an equal opportunity workplace and affirmative action employer.<\/p>","post_title":"Maintenance Technician","post_link":"https:\/\/turnerstaffing.com\/position\/maintenance-technician\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Associate","%location_country%":"United States","%location_city%":"Soda Springs","%location_state_id%":"ID","%location_state_name%":"Idaho","%location_city_state%":"Soda Springs, ID","%education%":"Unspecified","%department%":"Maintenance","%description%":"<p><strong>Maintenance Technician<\/strong>            &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; <\/p>\n<p><strong>Reports to: <\/strong><strong>Foreman \u2013 Turner Mining Group<\/strong><\/p>\n<p><strong>Job Description:<\/strong><\/p>\n<p>The Maintenance Technician is a skilled mining maintenance position within Turner Mining Group. This position will focus on maintaining equipment. The successful candidate must live the Turner Values and be an outward example to others. This position must demonstrate a strong commitment to \u201cSafe Production\u201d through decision making, priorities, and client relations.<\/p>\n<p><strong>Objectives and Contributions:<\/strong><\/p>\n<p>The Maintenance Technician is focused on key aspects that drive communication and safe production while maintaining a high level of efficiency, proactive training metrics, and preventative maintenance awareness requirements. The Maintenance Technician demonstrates safety ownership at a personal level and holds other crew members to the same high standard.&nbsp; The Maintenance Technician also assists in other production support functions as assigned.<\/p>\n<ul><li>Work with employees to ensure a high level of accuracy and engagement on hazard identification and control<\/li><li>Engage crews and leadership to define processes that motivate working towards common goals<\/li><li>Assist with MSHA regulatory training and verify compliance to standards<\/li><li>Live the values as part of a visible daily decision-making process<\/li><li>Assist with training proficiency audits<\/li><li>Involvement in risk assessment processes at various levels of the organization<\/li><li>Holds themselves and others accountable for acting like an owner (taking care of equipment, not wasting resources, using time wisely, and being accountable for conditions and behaviors)<\/li><li>Maintains a high standard of housekeeping (machine and work areas)<\/li><\/ul>\n<p><u>Culture and Communication:<\/u><\/p>\n<ul><li>Can effectively communicate in English (multi-lingual preferred)<\/li><li>Participate with site and project leaders to identify areas of improvement<\/li><li>Work with crews to support proactive near miss reporting<\/li><li>Leads by example (walks the talk)<\/li><\/ul>\n<p><u>Systems:<\/u><\/p>\n<ul><li>Ability to perform quality pre-operation machine inspections (Based on mobile equipment physical demands analysis)<\/li><li>Accurately documents 5000-23 and training checklist requirements<\/li><li>Other regulatory &amp; internal \/ external forms as required<\/li><\/ul>\n<p><u>Travel and New Site Development: <\/u><\/p>\n<ul><li>Maintains a valid and insurable driving license<\/li><li>Available to travel on short notice to support timelines and production requirements at existing sites <strong>(Preferred)<\/strong><\/li><\/ul>\n<p><u>Time and Interactions:<\/u><\/p>\n<ul><li>The Maintenance Technician must be flexible on shift schedules (days and nights) to assist with training and production needs<\/li><li>The Maintenance Technician will be self-starting, motivated, with a strong desire to be part of a team and to influence improvement. Communication is also critical to keep leadership and site-based personnel in the loop of successes, challenges, and any additional support that may be required<\/li><li>Excellent time management skills<\/li><\/ul>\n<p><u>Qualifications:<\/u><\/p>\n<ul><li>Willingness and ability to adhere to OSHA \/ MSHA regulatory requirements<\/li><li>1-3 years\u2019 experience in mining \/ heavy industry preferred<\/li><li>Working knowledge of safety systems and processes<\/li><li>Appropriate attention to detail required<\/li><li>Strong communication skills<\/li><li>Strong morals and values<\/li><li>Exemplary attendance record<\/li><li>Exemplary safety and disciplinary record<\/li><li>Willingness to be flexible on daily job duty requirements<\/li><li>Maintains a positive outspoken learning attitude<\/li><li>The Maintenance Technician must be able to safely perform each of the following tasks: <ul><li><strong>Maintenance service truck<\/strong><\/li><li><strong><\/strong><strong>G.E.T replacement<\/strong><\/li><li><strong><\/strong><strong>Replacing equipment attachments<\/strong><\/li><li><strong><\/strong><strong>Minor equipment repairs<\/strong><\/li><li><strong><\/strong><strong>Preventative maintenance backlog repairs<\/strong><\/li><li><strong><\/strong><strong>Fuel \/ lube Truck<\/strong><\/li><li><strong><\/strong><strong>Fueling \/ lubing equipment<\/strong><\/li><li><strong><\/strong><strong>Equipment fluid level monitoring<\/strong><\/li><li><strong><\/strong><strong>Marshalling equipment<\/strong><\/li><li><strong><\/strong><strong>Washing equipment<\/strong><\/li><\/ul><\/li><\/ul>\n<p><u>Other Duties:<\/u><\/p>\n<ul><li>In addition to the job skills above, there may be requirements for manual tasks to be completed to meet other business needs. Operators in any job duty classification may be required to participate in these additional tasks.<u><\/u><\/li><\/ul><p><u><strong>Benefits<\/strong><\/u><br>Turner Mining Group offers a competitive salary, an excellent work culture, and career advancement opportunities. Our team provides a benefits program which includes Medical, Dental, Vision, Life, and a 401k with company match. We believe in a work-life balance and have established paid time off for major holidays.<\/p>\n<p>At Turner Mining Group, we encourage and celebrate an inclusive environment for all employees and are proud to be an equal opportunity workplace and affirmative action employer.<\/p>","%category%":"Operations","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/3905c4296b03-maintenance-technician","%breezy_id%":"3905c4296b03","%breezy_friendly_id%":"3905c4296b03-maintenance-technician","%breezy_created_date%":"2025-09-04T22:58:10.896Z","%breezy_updated_date%":"2025-09-16T14:57:25.706Z","%_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":2736,"infowindow_disable":false},{"source":"post","title":"Entry Level Miner","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Entry Level Miner\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Entry Level Miner &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; Reports to: Foreman \u2013 Turner Mining Group Job Description: The Entry Level Miner is a starting&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/entry-level-miner\/\" name=\"Entry Level Miner\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Entry Level Miner &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; Reports to: Foreman \u2013 Turner Mining Group Job Description: The Entry Level Miner is a starting&hellip;","address":"Soda Springs, ID, USA","location":{"lat":"42.6543652","city":"Soda Springs","state":"ID","country":"United States","lng":"-111.6046687","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/entry-level-miner\/","zoom":19,"extra_fields":{"post_excerpt":"Entry Level Miner &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; Reports to: Foreman \u2013 Turner Mining Group Job Description: The Entry Level Miner is a starting&hellip;","post_content":"<p><strong>Entry Level Miner<\/strong>                &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; <\/p>\n<p><strong>Reports to: <\/strong><strong>Foreman \u2013 Turner Mining Group<\/strong><\/p>\n<p><strong>Job Description:<\/strong><\/p>\n<p>The Entry Level Miner is a starting point for both operations and maintenance within Turner Mining Group. This position will develop into a Production Miner or Fuel \/ Lube Technician role. The successful candidate must live the Turner Values and be an outward example to others. This position must demonstrate a strong commitment to \u201cSafe Production\u201d through decision making, priorities, and client relations.<\/p>\n<p><strong>Objectives and Contributions:<\/strong><\/p>\n<p>The Entry Level Miner is focused on key aspects that drive communication and safe production while maintaining a high level of efficiency, and preventative maintenance awareness requirements. The Entry Level Miner demonstrates safety ownership at a personal level and holds other crew members to the same high standard. <\/p>\n<ul><li>Work with employees to ensure a high level of accuracy and engagement on hazard identification and control<\/li><li>Engage crews and leadership to define processes that motivate working towards common goals<\/li><li>Assist with MSHA regulatory task training and verify compliance to standards<\/li><li>Live the values as part of a visible daily decision-making process<\/li><li>Involvement in risk assessment processes at various levels of the organization<\/li><li>Holds themselves and others accountable for acting like an owner (taking care of equipment, not wasting resources, using time wisely, and being accountable for conditions and behaviors)<\/li><li>Maintains a high standard of housekeeping (machine and work areas)<\/li><\/ul>\n<p><u>Culture and Communication:<\/u><\/p>\n<ul><li>Can effectively communicate in English (multi-lingual preferred)<\/li><li>Work with crews to support proactive near miss reporting<\/li><li>Leads by example (walks the talk)<\/li><\/ul>\n<p><u>Systems:<\/u><\/p>\n<ul><li>Trains to Turner standards to perform quality pre-operation machine inspections (Based on mobile equipment physical demands analysis)<\/li><li>Trains to Turner standards to accurately document 5000-23 and training checklist requirements<\/li><li>Other regulatory &amp; internal \/ external forms as required<\/li><li>Maintains a valid and insurable driving license<\/li><\/ul>\n<p><u>Travel and New Site Development: <\/u><\/p>\n<p><u>Time and Interactions:<\/u><\/p>\n<ul><li>The Entry Level Miner must be flexible on shift schedules (days and nights) to assist with training and production needs<\/li><li>The Entry Level Miner will be self-starting, motivated, with a strong desire to be part of a team and to influence improvement. Communication is also critical to keep leadership and site-based personnel in the loop of successes, challenges, and any additional support that may be required<\/li><li>Excellent time management skills<\/li><\/ul>\n<p><u>Qualifications:<\/u><\/p>\n<ul><li>Willingness and ability to adhere to OSHA \/ MSHA regulatory requirements<\/li><li>Entry Level Miners will be subject to a probationary period of six months from the date of hire<\/li><li>0-1 years\u2019 experience in mining \/ heavy industry preferred<\/li><li>Ability to obtain a working knowledge of safety systems and processes<\/li><li>Appropriate attention to detail required<\/li><li>Strong communication skills<\/li><li>Strong morals and values<\/li><li>Exemplary attendance record<\/li><li>Exemplary safety and disciplinary record<\/li><li>Willingness to be flexible on daily job duty requirements<\/li><li>Maintains a positive outspoken learning attitude<\/li><\/ul>\n<ul><li>The Entry Level Miner will become competent and highly proficient on each piece of the following equipment through on-the-job training and skills qualification<ul><li><strong>Water truck<\/strong><\/li><li><strong><\/strong><strong>Haulage Truc<\/strong><strong>k<\/strong><\/li><li><strong><\/strong><strong>OR<\/strong><\/li><li><strong><\/strong><strong>Preventative Maintenance<\/strong><\/li><li><strong><\/strong><strong>Fuel \/ Lube Truck<\/strong><\/li><\/ul><\/li><\/ul>\n<p><u>Other Duties:<\/u><\/p>\n<ul><li>In addition to the job skills above, there may be requirements for manual tasks to be completed to meet other business needs. Operators in any job duty classification may be required to participate in these additional tasks.<\/li><\/ul>\n<p><u><strong>Benefits<\/strong><\/u><br>Turner Mining Group offers a competitive salary, an excellent work culture, and career advancement opportunities. Our team provides a benefits program which includes Medical, Dental, Vision, Life, and a 401k with company match. We believe in a work-life balance and have established paid time off for major holidays.<\/p>\n<p>At Turner Mining Group, we encourage and celebrate an inclusive environment for all employees and are proud to be an equal opportunity workplace and affirmative action employer.<\/p>\n<p><u><br><\/u><\/p>","post_title":"Entry Level Miner","post_link":"https:\/\/turnerstaffing.com\/position\/entry-level-miner\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Entry Level","%location_country%":"United States","%location_city%":"Soda Springs","%location_state_id%":"ID","%location_state_name%":"Idaho","%location_city_state%":"Soda Springs, ID","%education%":"Unspecified","%department%":"Operations","%description%":"<p><strong>Entry Level Miner<\/strong>                &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; <\/p>\n<p><strong>Reports to: <\/strong><strong>Foreman \u2013 Turner Mining Group<\/strong><\/p>\n<p><strong>Job Description:<\/strong><\/p>\n<p>The Entry Level Miner is a starting point for both operations and maintenance within Turner Mining Group. This position will develop into a Production Miner or Fuel \/ Lube Technician role. The successful candidate must live the Turner Values and be an outward example to others. This position must demonstrate a strong commitment to \u201cSafe Production\u201d through decision making, priorities, and client relations.<\/p>\n<p><strong>Objectives and Contributions:<\/strong><\/p>\n<p>The Entry Level Miner is focused on key aspects that drive communication and safe production while maintaining a high level of efficiency, and preventative maintenance awareness requirements. The Entry Level Miner demonstrates safety ownership at a personal level and holds other crew members to the same high standard. <\/p>\n<ul><li>Work with employees to ensure a high level of accuracy and engagement on hazard identification and control<\/li><li>Engage crews and leadership to define processes that motivate working towards common goals<\/li><li>Assist with MSHA regulatory task training and verify compliance to standards<\/li><li>Live the values as part of a visible daily decision-making process<\/li><li>Involvement in risk assessment processes at various levels of the organization<\/li><li>Holds themselves and others accountable for acting like an owner (taking care of equipment, not wasting resources, using time wisely, and being accountable for conditions and behaviors)<\/li><li>Maintains a high standard of housekeeping (machine and work areas)<\/li><\/ul>\n<p><u>Culture and Communication:<\/u><\/p>\n<ul><li>Can effectively communicate in English (multi-lingual preferred)<\/li><li>Work with crews to support proactive near miss reporting<\/li><li>Leads by example (walks the talk)<\/li><\/ul>\n<p><u>Systems:<\/u><\/p>\n<ul><li>Trains to Turner standards to perform quality pre-operation machine inspections (Based on mobile equipment physical demands analysis)<\/li><li>Trains to Turner standards to accurately document 5000-23 and training checklist requirements<\/li><li>Other regulatory &amp; internal \/ external forms as required<\/li><li>Maintains a valid and insurable driving license<\/li><\/ul>\n<p><u>Travel and New Site Development: <\/u><\/p>\n<p><u>Time and Interactions:<\/u><\/p>\n<ul><li>The Entry Level Miner must be flexible on shift schedules (days and nights) to assist with training and production needs<\/li><li>The Entry Level Miner will be self-starting, motivated, with a strong desire to be part of a team and to influence improvement. Communication is also critical to keep leadership and site-based personnel in the loop of successes, challenges, and any additional support that may be required<\/li><li>Excellent time management skills<\/li><\/ul>\n<p><u>Qualifications:<\/u><\/p>\n<ul><li>Willingness and ability to adhere to OSHA \/ MSHA regulatory requirements<\/li><li>Entry Level Miners will be subject to a probationary period of six months from the date of hire<\/li><li>0-1 years\u2019 experience in mining \/ heavy industry preferred<\/li><li>Ability to obtain a working knowledge of safety systems and processes<\/li><li>Appropriate attention to detail required<\/li><li>Strong communication skills<\/li><li>Strong morals and values<\/li><li>Exemplary attendance record<\/li><li>Exemplary safety and disciplinary record<\/li><li>Willingness to be flexible on daily job duty requirements<\/li><li>Maintains a positive outspoken learning attitude<\/li><\/ul>\n<ul><li>The Entry Level Miner will become competent and highly proficient on each piece of the following equipment through on-the-job training and skills qualification<ul><li><strong>Water truck<\/strong><\/li><li><strong><\/strong><strong>Haulage Truc<\/strong><strong>k<\/strong><\/li><li><strong><\/strong><strong>OR<\/strong><\/li><li><strong><\/strong><strong>Preventative Maintenance<\/strong><\/li><li><strong><\/strong><strong>Fuel \/ Lube Truck<\/strong><\/li><\/ul><\/li><\/ul>\n<p><u>Other Duties:<\/u><\/p>\n<ul><li>In addition to the job skills above, there may be requirements for manual tasks to be completed to meet other business needs. Operators in any job duty classification may be required to participate in these additional tasks.<\/li><\/ul>\n<p><u><strong>Benefits<\/strong><\/u><br>Turner Mining Group offers a competitive salary, an excellent work culture, and career advancement opportunities. Our team provides a benefits program which includes Medical, Dental, Vision, Life, and a 401k with company match. We believe in a work-life balance and have established paid time off for major holidays.<\/p>\n<p>At Turner Mining Group, we encourage and celebrate an inclusive environment for all employees and are proud to be an equal opportunity workplace and affirmative action employer.<\/p>\n<p><u><br><\/u><\/p>","%category%":"Operations","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/59bf9ba6d66b-entry-level-miner","%breezy_id%":"59bf9ba6d66b","%breezy_friendly_id%":"59bf9ba6d66b-entry-level-miner","%breezy_created_date%":"2025-09-04T22:47:23.331Z","%breezy_updated_date%":"2025-10-14T15:22:49.037Z","%_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":2733,"infowindow_disable":false},{"source":"post","title":"Equipment Operator","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Equipment Operator\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Equipment Operator &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; Reports to: Foreman \u2013 Turner Mining Group Job Description: The Equipment Operator is a skilled mining operator&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/equipment-operator\/\" name=\"Equipment Operator\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Equipment Operator &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; Reports to: Foreman \u2013 Turner Mining Group Job Description: The Equipment Operator is a skilled mining operator&hellip;","address":"Soda Springs, ID, USA","location":{"lat":"42.6543652","city":"Soda Springs","state":"ID","country":"United States","lng":"-111.6046687","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/equipment-operator\/","zoom":19,"extra_fields":{"post_excerpt":"Equipment Operator &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; Reports to: Foreman \u2013 Turner Mining Group Job Description: The Equipment Operator is a skilled mining operator&hellip;","post_content":"<p><strong>Equipment Operator<\/strong>            &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; <\/p>\n<p><strong>Reports to: <\/strong><strong>Foreman \u2013 Turner Mining Group<\/strong><\/p>\n<p><strong>Job Description:<\/strong><\/p>\n<p>The Equipment Operator is a skilled mining operator position within Turner Mining Group. The successful candidate must live the Turner Values and be an outward example to others. This position must demonstrate a strong commitment to \u201cSafe Production\u201d through decision making, priorities, and client relations.<\/p>\n<p><strong>Objectives and Contributions:<\/strong><\/p>\n<p>The Equipment Operator is focused on key aspects that drive communication and safe production while maintaining a high level of efficiency, and preventative maintenance awareness requirements. The Operator demonstrates safety ownership at a personal level and holds other crew members to the same high standard.&nbsp; The Equipment Operator will train and develop into the Senior Equipment Operator job scope while the Senior Equipment operator is filling in for the Lead job duties. <\/p>\n<ul><li>Work with employees to ensure a high level of accuracy and engagement on hazard identification and control<\/li><li>Engage crews and leadership to define processes that motivate working towards common goals<\/li><li>Assist with MSHA regulatory task training and verify compliance to standards<\/li><li>Live the values as part of a visible daily decision-making process<\/li><li>Assist with training proficiency audits<\/li><li>Involvement in risk assessment processes at various levels of the organization<\/li><li>Holds themselves and others accountable for acting like an owner (taking care of equipment, not wasting resources, using time wisely, and being accountable for conditions and behaviors)<\/li><li>Maintains a high standard of housekeeping (machine and work areas)<\/li><\/ul>\n<p><u>Culture and Communication:<\/u><\/p>\n<ul><li>Can effectively communicate in English (multi-lingual preferred)<\/li><li>Participate in site and project leaders to identify areas of improvement<\/li><li>Work with crews to support proactive near miss reporting<\/li><li>Leads by example (walks the talk)<\/li><\/ul>\n<p><u>Systems:<\/u><\/p>\n<ul><li>Ability to perform quality pre-operation machine inspections (Based on mobile equipment physical demands analysis)<\/li><li>Accurately documents 5000-23 and training checklist requirements<\/li><li>Other regulatory &amp; internal \/ external forms as required<\/li><\/ul>\n<p><u>Travel and New Site Development:<\/u><\/p>\n<ul><li>Maintains a valid and insurable driving license<\/li><li>Available to travel on short notice to support timelines and production requirements at existing sites<\/li><\/ul>\n<p><u>Time and Interactions:<\/u><\/p>\n<ul><li>The Equipment Operator must be flexible on shift schedules (days and nights) to assist with training and production needs<\/li><li>The Equipment Operator will be self-starting, motivated, with a strong desire to be part of a team and to influence improvement. Communication is also critical to keep leadership and site-based personnel in the loop of successes, challenges, and any additional support that may be required<\/li><li>Excellent time management skills<\/li><\/ul>\n<p><u>Qualifications:<\/u><\/p>\n<ul><li>Willingness and ability to adhere to OSHA \/ MSHA regulatory requirements<\/li><li>1-3 years\u2019 experience in mining \/ heavy industry preferred<\/li><li>Working knowledge of safety systems and processes<\/li><li>Appropriate attention to detail required<\/li><li>Strong communication skills<\/li><li>Strong morals and values<\/li><li>Exemplary attendance record<\/li><li>Exemplary safety and disciplinary record<\/li><li>Willingness to be flexible on daily job duty requirements<\/li><li>Maintains a positive outspoken learning attitude<\/li><li>The Equipment Operator must pass and maintain Turner Mining Group mobile equipment skills qualifications on each piece of the following equipment: <ul><li><strong>Support excavator<\/strong><\/li><li><strong><\/strong><strong>Dozer<\/strong><\/li><li><strong><\/strong><strong>Support loader<\/strong><\/li><li><strong><\/strong><strong>Grader<\/strong><\/li><li><strong><\/strong><strong>Water truck<\/strong><\/li><li><strong><\/strong><strong>Haulage truck<\/strong><\/li><\/ul><\/li><\/ul>\n<p><u>Other Duties:<\/u><\/p>\n<ul><li>In addition to the job skills above, there may be requirements for manual tasks to be completed to meet other business needs. Operators in any job duty classification may be required to participate in these additional tasks.<u><\/u><\/li><\/ul><p><u><strong>Benefits<\/strong><\/u><br>Turner Mining Group offers a competitive salary, an excellent work culture, and career advancement opportunities. Our team provides a benefits program which includes Medical, Dental, Vision, Life, and a 401k with company match. We believe in a work-life balance and have established paid time off for major holidays.<\/p>\n<p>At Turner Mining Group, we encourage and celebrate an inclusive environment for all employees and are proud to be an equal opportunity workplace and affirmative action employer.<\/p>","post_title":"Equipment Operator","post_link":"https:\/\/turnerstaffing.com\/position\/equipment-operator\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Associate","%location_country%":"United States","%location_city%":"Soda Springs","%location_state_id%":"ID","%location_state_name%":"Idaho","%location_city_state%":"Soda Springs, ID","%education%":"Unspecified","%department%":"Operations","%description%":"<p><strong>Equipment Operator<\/strong>            &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; <\/p>\n<p><strong>Reports to: <\/strong><strong>Foreman \u2013 Turner Mining Group<\/strong><\/p>\n<p><strong>Job Description:<\/strong><\/p>\n<p>The Equipment Operator is a skilled mining operator position within Turner Mining Group. The successful candidate must live the Turner Values and be an outward example to others. This position must demonstrate a strong commitment to \u201cSafe Production\u201d through decision making, priorities, and client relations.<\/p>\n<p><strong>Objectives and Contributions:<\/strong><\/p>\n<p>The Equipment Operator is focused on key aspects that drive communication and safe production while maintaining a high level of efficiency, and preventative maintenance awareness requirements. The Operator demonstrates safety ownership at a personal level and holds other crew members to the same high standard.&nbsp; The Equipment Operator will train and develop into the Senior Equipment Operator job scope while the Senior Equipment operator is filling in for the Lead job duties. <\/p>\n<ul><li>Work with employees to ensure a high level of accuracy and engagement on hazard identification and control<\/li><li>Engage crews and leadership to define processes that motivate working towards common goals<\/li><li>Assist with MSHA regulatory task training and verify compliance to standards<\/li><li>Live the values as part of a visible daily decision-making process<\/li><li>Assist with training proficiency audits<\/li><li>Involvement in risk assessment processes at various levels of the organization<\/li><li>Holds themselves and others accountable for acting like an owner (taking care of equipment, not wasting resources, using time wisely, and being accountable for conditions and behaviors)<\/li><li>Maintains a high standard of housekeeping (machine and work areas)<\/li><\/ul>\n<p><u>Culture and Communication:<\/u><\/p>\n<ul><li>Can effectively communicate in English (multi-lingual preferred)<\/li><li>Participate in site and project leaders to identify areas of improvement<\/li><li>Work with crews to support proactive near miss reporting<\/li><li>Leads by example (walks the talk)<\/li><\/ul>\n<p><u>Systems:<\/u><\/p>\n<ul><li>Ability to perform quality pre-operation machine inspections (Based on mobile equipment physical demands analysis)<\/li><li>Accurately documents 5000-23 and training checklist requirements<\/li><li>Other regulatory &amp; internal \/ external forms as required<\/li><\/ul>\n<p><u>Travel and New Site Development:<\/u><\/p>\n<ul><li>Maintains a valid and insurable driving license<\/li><li>Available to travel on short notice to support timelines and production requirements at existing sites<\/li><\/ul>\n<p><u>Time and Interactions:<\/u><\/p>\n<ul><li>The Equipment Operator must be flexible on shift schedules (days and nights) to assist with training and production needs<\/li><li>The Equipment Operator will be self-starting, motivated, with a strong desire to be part of a team and to influence improvement. Communication is also critical to keep leadership and site-based personnel in the loop of successes, challenges, and any additional support that may be required<\/li><li>Excellent time management skills<\/li><\/ul>\n<p><u>Qualifications:<\/u><\/p>\n<ul><li>Willingness and ability to adhere to OSHA \/ MSHA regulatory requirements<\/li><li>1-3 years\u2019 experience in mining \/ heavy industry preferred<\/li><li>Working knowledge of safety systems and processes<\/li><li>Appropriate attention to detail required<\/li><li>Strong communication skills<\/li><li>Strong morals and values<\/li><li>Exemplary attendance record<\/li><li>Exemplary safety and disciplinary record<\/li><li>Willingness to be flexible on daily job duty requirements<\/li><li>Maintains a positive outspoken learning attitude<\/li><li>The Equipment Operator must pass and maintain Turner Mining Group mobile equipment skills qualifications on each piece of the following equipment: <ul><li><strong>Support excavator<\/strong><\/li><li><strong><\/strong><strong>Dozer<\/strong><\/li><li><strong><\/strong><strong>Support loader<\/strong><\/li><li><strong><\/strong><strong>Grader<\/strong><\/li><li><strong><\/strong><strong>Water truck<\/strong><\/li><li><strong><\/strong><strong>Haulage truck<\/strong><\/li><\/ul><\/li><\/ul>\n<p><u>Other Duties:<\/u><\/p>\n<ul><li>In addition to the job skills above, there may be requirements for manual tasks to be completed to meet other business needs. Operators in any job duty classification may be required to participate in these additional tasks.<u><\/u><\/li><\/ul><p><u><strong>Benefits<\/strong><\/u><br>Turner Mining Group offers a competitive salary, an excellent work culture, and career advancement opportunities. Our team provides a benefits program which includes Medical, Dental, Vision, Life, and a 401k with company match. We believe in a work-life balance and have established paid time off for major holidays.<\/p>\n<p>At Turner Mining Group, we encourage and celebrate an inclusive environment for all employees and are proud to be an equal opportunity workplace and affirmative action employer.<\/p>","%category%":"Operations","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/df0d53766ad0-equipment-operator","%breezy_id%":"df0d53766ad0","%breezy_friendly_id%":"df0d53766ad0-equipment-operator","%breezy_created_date%":"2025-09-04T22:49:29.085Z","%breezy_updated_date%":"2025-09-16T14:52:41.519Z","%_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":2734,"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-09-08T17:05:53.942Z","%_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":2732,"infowindow_disable":false},{"source":"post","title":"Production Miner","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Production Miner\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Production Miner &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; Reports to: Foreman \u2013 Turner Mining Group Job Description: The Production Miner is a developing mining operator&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/production-miner\/\" name=\"Production Miner\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Production Miner &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; Reports to: Foreman \u2013 Turner Mining Group Job Description: The Production Miner is a developing mining operator&hellip;","address":"Soda Spring, ID, USA","location":{"lat":"42.6543652","city":"Soda Spring","state":"ID","country":"United States","lng":"-111.6046687","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/production-miner\/","zoom":19,"extra_fields":{"post_excerpt":"Production Miner &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; Reports to: Foreman \u2013 Turner Mining Group Job Description: The Production Miner is a developing mining operator&hellip;","post_content":"<p><strong>Production Miner<\/strong>                &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; <\/p>\n<p><strong>Reports to: <\/strong><strong>Foreman \u2013 Turner Mining Group<\/strong><\/p>\n<p><strong>Job Description:<\/strong><\/p>\n<p>The Production Miner is a developing mining operator position within Turner Mining Group. The successful candidate must live the Turner Values and be an outward example to others. This position must demonstrate a strong commitment to \u201cSafe Production\u201d through decision making, priorities, and client relations.<\/p>\n<p><strong>Objectives and Contributions:<\/strong><\/p>\n<p>The Production Miner is focused on key aspects that drive communication and safe production while maintaining a high level of efficiency, and preventative maintenance awareness requirements. The Production Miner demonstrates safety ownership at a personal level and holds other crew members to the same high standard.&nbsp; The Production Miner will train and develop into the Equipment Operator job scope while the Equipment operator is filling in for the Senior job duties.<\/p>\n<ul><li>Work with employees to ensure a high level of accuracy and engagement on hazard identification and control<\/li><li>Engage crews and leadership to define processes that motivate working towards common goals<\/li><li>Assist with MSHA regulatory task training and verify compliance to standards<\/li><li>Live the values as part of a visible daily decision-making process<\/li><li>Assist with training proficiency audits<\/li><li>Involvement in risk assessment processes at various levels of the organization<\/li><li>Holds themselves and others accountable for acting like an owner (taking care of equipment, not wasting resources, using time wisely, and being accountable for conditions and behaviors)<\/li><li>Maintains a high standard of housekeeping (machine and work areas)<\/li><\/ul>\n<p><u>Culture and Communication:<\/u><\/p>\n<ul><li>Can effectively communicate in English (multi-lingual preferred)<\/li><li>Participate in site and project leaders to identify areas of improvement<\/li><li>Work with crews to support proactive near miss reporting<\/li><li>Leads by example (walks the talk)<\/li><\/ul>\n<p><u>Systems:<\/u><\/p>\n<ul><li>Ability to perform quality pre-operation machine inspections (Based on mobile equipment physical demands analysis)<\/li><li>Accurately documents 5000-23 and training checklist requirements<\/li><li>Other regulatory &amp; internal \/ external forms as required<\/li><li>Maintains a valid and insurable driving license<\/li><\/ul>\n<p><u>Travel and New Site Development: <\/u><\/p>\n<p><u>Time and Interactions:<\/u><\/p>\n<ul><li>The Production Miner must be flexible on shift schedules (days and nights) to assist with training and production needs<\/li><li>The Production Miner will be self-starting, motivated, with a strong desire to be part of a team and to influence improvement. Communication is also critical to keep leadership and site-based personnel in the loop of successes, challenges, and any additional support that may be required<\/li><li>Excellent time management skills<\/li><\/ul>\n<p><u>Qualifications:<\/u><\/p>\n<ul><li>Willingness and ability to adhere to OSHA \/ MSHA regulatory requirements<\/li><li>Production Miner will be subject to a probationary period of six months from the date of hire<\/li><li>0-2 years\u2019 experience in mining \/ heavy industry preferred<\/li><li>Working knowledge of safety systems and processes<\/li><li>Appropriate attention to detail required<\/li><li>Strong communication skills<\/li><li>Strong morals and values<\/li><li>Exemplary attendance record<\/li><li>Exemplary safety and disciplinary record<\/li><li>Willingness to be flexible on daily job duty requirements<\/li><li>Maintains a positive outspoken learning attitude<\/li><li>The Production Miner will be competent and highly proficient on each piece of the following equipment: <ul><li><strong>Water truck,<\/strong><\/li><li><strong><\/strong><strong>Haulage Truck<\/strong><\/li><\/ul><\/li><\/ul>\n<p><u>Other Duties:<\/u><\/p>\n<ul><li>In addition to the job skills above, there may be requirements for manual tasks to be completed to meet other business needs. Operators in any job duty classification may be required to participate in these additional tasks.<\/li><\/ul>\n<p><u><strong>Benefits<\/strong><\/u><br>Turner Mining Group offers a competitive salary, an excellent work culture, and career advancement opportunities. Our team provides a benefits program which includes Medical, Dental, Vision, Life, and a 401k with company match. We believe in a work-life balance and have established paid time off for major holidays.<\/p>\n<p>At Turner Mining Group, we encourage and celebrate an inclusive environment for all employees and are proud to be an equal opportunity workplace and affirmative action employer.<\/p><p><u><br><\/u><\/p>","post_title":"Production Miner","post_link":"https:\/\/turnerstaffing.com\/position\/production-miner\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Entry Level","%location_country%":"United States","%location_city%":"Soda Spring","%location_state_id%":"ID","%location_state_name%":"Idaho","%location_city_state%":"Soda Spring, ID","%education%":"Unspecified","%department%":"Operations","%description%":"<p><strong>Production Miner<\/strong>                &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; <\/p>\n<p><strong>Reports to: <\/strong><strong>Foreman \u2013 Turner Mining Group<\/strong><\/p>\n<p><strong>Job Description:<\/strong><\/p>\n<p>The Production Miner is a developing mining operator position within Turner Mining Group. The successful candidate must live the Turner Values and be an outward example to others. This position must demonstrate a strong commitment to \u201cSafe Production\u201d through decision making, priorities, and client relations.<\/p>\n<p><strong>Objectives and Contributions:<\/strong><\/p>\n<p>The Production Miner is focused on key aspects that drive communication and safe production while maintaining a high level of efficiency, and preventative maintenance awareness requirements. The Production Miner demonstrates safety ownership at a personal level and holds other crew members to the same high standard.&nbsp; The Production Miner will train and develop into the Equipment Operator job scope while the Equipment operator is filling in for the Senior job duties.<\/p>\n<ul><li>Work with employees to ensure a high level of accuracy and engagement on hazard identification and control<\/li><li>Engage crews and leadership to define processes that motivate working towards common goals<\/li><li>Assist with MSHA regulatory task training and verify compliance to standards<\/li><li>Live the values as part of a visible daily decision-making process<\/li><li>Assist with training proficiency audits<\/li><li>Involvement in risk assessment processes at various levels of the organization<\/li><li>Holds themselves and others accountable for acting like an owner (taking care of equipment, not wasting resources, using time wisely, and being accountable for conditions and behaviors)<\/li><li>Maintains a high standard of housekeeping (machine and work areas)<\/li><\/ul>\n<p><u>Culture and Communication:<\/u><\/p>\n<ul><li>Can effectively communicate in English (multi-lingual preferred)<\/li><li>Participate in site and project leaders to identify areas of improvement<\/li><li>Work with crews to support proactive near miss reporting<\/li><li>Leads by example (walks the talk)<\/li><\/ul>\n<p><u>Systems:<\/u><\/p>\n<ul><li>Ability to perform quality pre-operation machine inspections (Based on mobile equipment physical demands analysis)<\/li><li>Accurately documents 5000-23 and training checklist requirements<\/li><li>Other regulatory &amp; internal \/ external forms as required<\/li><li>Maintains a valid and insurable driving license<\/li><\/ul>\n<p><u>Travel and New Site Development: <\/u><\/p>\n<p><u>Time and Interactions:<\/u><\/p>\n<ul><li>The Production Miner must be flexible on shift schedules (days and nights) to assist with training and production needs<\/li><li>The Production Miner will be self-starting, motivated, with a strong desire to be part of a team and to influence improvement. Communication is also critical to keep leadership and site-based personnel in the loop of successes, challenges, and any additional support that may be required<\/li><li>Excellent time management skills<\/li><\/ul>\n<p><u>Qualifications:<\/u><\/p>\n<ul><li>Willingness and ability to adhere to OSHA \/ MSHA regulatory requirements<\/li><li>Production Miner will be subject to a probationary period of six months from the date of hire<\/li><li>0-2 years\u2019 experience in mining \/ heavy industry preferred<\/li><li>Working knowledge of safety systems and processes<\/li><li>Appropriate attention to detail required<\/li><li>Strong communication skills<\/li><li>Strong morals and values<\/li><li>Exemplary attendance record<\/li><li>Exemplary safety and disciplinary record<\/li><li>Willingness to be flexible on daily job duty requirements<\/li><li>Maintains a positive outspoken learning attitude<\/li><li>The Production Miner will be competent and highly proficient on each piece of the following equipment: <ul><li><strong>Water truck,<\/strong><\/li><li><strong><\/strong><strong>Haulage Truck<\/strong><\/li><\/ul><\/li><\/ul>\n<p><u>Other Duties:<\/u><\/p>\n<ul><li>In addition to the job skills above, there may be requirements for manual tasks to be completed to meet other business needs. Operators in any job duty classification may be required to participate in these additional tasks.<\/li><\/ul>\n<p><u><strong>Benefits<\/strong><\/u><br>Turner Mining Group offers a competitive salary, an excellent work culture, and career advancement opportunities. Our team provides a benefits program which includes Medical, Dental, Vision, Life, and a 401k with company match. We believe in a work-life balance and have established paid time off for major holidays.<\/p>\n<p>At Turner Mining Group, we encourage and celebrate an inclusive environment for all employees and are proud to be an equal opportunity workplace and affirmative action employer.<\/p><p><u><br><\/u><\/p>","%category%":"Operations","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/17290badbf9e-production-miner","%breezy_id%":"17290badbf9e","%breezy_friendly_id%":"17290badbf9e-production-miner","%breezy_created_date%":"2025-09-04T23:00:11.071Z","%breezy_updated_date%":"2025-09-16T14:55:57.105Z","%_wpgmp_location_city%":"Soda Spring","%_wpgmp_location_state%":"ID","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Soda Spring, ID, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"42.6543652","%_wpgmp_metabox_longitude%":"-111.6046687","%rank_math_internal_links_processed%":"1"}},"id":2729,"infowindow_disable":false},{"source":"post","title":"Fuel\/Lube Technician &#8211; Mining","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Fuel\/Lube Technician &#8211; Mining\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Turner Mining Group &#8211; Heavy Equipment Fuel &amp; Lube TechnicianWe are looking for a dynamic and talented professional to fill&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/fuel-lube-technician-mining-2\/\" name=\"Fuel\/Lube Technician &#8211; Mining\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Turner Mining Group &#8211; Heavy Equipment Fuel &amp; Lube TechnicianWe are looking for a dynamic and talented professional to fill&hellip;","address":"Crane, TX, USA","location":{"lat":"31.3973624","city":"Crane","state":"TX","country":"United States","lng":"-102.3501419","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/fuel-lube-technician-mining-2\/","zoom":19,"extra_fields":{"post_excerpt":"Turner Mining Group &#8211; Heavy Equipment Fuel &amp; Lube TechnicianWe are looking for a dynamic and talented professional to fill&hellip;","post_content":"<p><strong><u>Turner Mining Group - Heavy Equipment Fuel &amp; Lube Technician<\/u><\/strong><br>We are looking for a dynamic and talented professional to fill a <strong>Fuel &amp; Lube Technician<\/strong> role at our fast-growing, forward thinking mining services company.<\/p>\n\n<p style=\"color:#000000\"><span style=\"color:#333333\"> <\/span><\/p>\n<p>This person will function as a <strong>Fuel &amp; Lube Technician<\/strong><span style=\"color:#333333\">, willingness to do, learn, perform and improve any maintenance task. Tasks will be defined and evolve in all areas of mining operations to ensure preventative maintenance is practiced, repairs, equipment runs in the area of responsibility. This is an opportunity to work as part of the operations team in a safe, productive, and fun environment.<\/span> <span style=\"color:#333333\"><\/span><\/p>\n\n\n<p><strong>Essential Skills &amp; Knowledge<\/strong><\/p>\n<p style=\"color:#000000\"><span style=\"color:#333333\">\u2022 Follow a consistent and regular schedule to perform various types of maintenance on heavy equipment and various pieces of machinery <\/span><\/p>\n<p style=\"color:#000000\"><span style=\"color:#333333\">\u2022 Perform minor repairs on equipment using tools, machine tools and measuring instruments <\/span><\/p>\n<p style=\"color:#000000\"><span style=\"color:#333333\">\u2022 Conduct oil changes, lubrication of equipment, tire replacements, hose repairs, battery replacements and assorted services <\/span><\/p>\n<p style=\"color:#000000\"><span style=\"color:#333333\">\u2022 Operate and test equipment <\/span><\/p>\n<p style=\"color:#000000\"><span style=\"color:#333333\">\u2022 Produce detailed service reports and repair logs <\/span><\/p>\n<p style=\"color:#000000\"><span style=\"color:#333333\">\u2022 Follow all established procedures and protocols <\/span><\/p>\n<p style=\"color:#000000\"><span style=\"color:#333333\">\u2022 Build positive relationships with internal and external teams<\/span><\/p>\n<p style=\"color:#000000\"><span style=\"color:#333333\">\u2022 Perform additional duties as assigned<\/span><\/p>\n<p style=\"color:#000000\"><span style=\"color:#333333\"> <\/span><\/p>\n<p><strong>Benefits<\/strong><\/p>\n<p style=\"color:#000000\"><span style=\"color:#333333\">Turner Mining Group offers a competitive salary, an excellent work culture, career advancement opportunities. Our team offers a benefits program which includes Medical, Dental, Vision, Life, and a 401k with company match. We believe in a work life balance and established paid time off for major holidays.<\/span><\/p>\n<p style=\"color:#000000\"><span style=\"color:#333333\"> <\/span><\/p>\n<p>At Turner Mining Group, we encourage and celebrate an inclusive environment for all employees and are proud to be an equal opportunity workplace and affirmative action employer.<\/p>\n<p><\/p>","post_title":"Fuel\/Lube Technician &#8211; Mining","post_link":"https:\/\/turnerstaffing.com\/position\/fuel-lube-technician-mining-2\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Entry Level","%location_country%":"United States","%location_city%":"Crane","%location_state_id%":"TX","%location_state_name%":"Texas","%location_city_state%":"Crane, TX","%education%":"Unspecified","%department%":"Maintenance","%description%":"<p><strong><u>Turner Mining Group - Heavy Equipment Fuel &amp; Lube Technician<\/u><\/strong><br>We are looking for a dynamic and talented professional to fill a <strong>Fuel &amp; Lube Technician<\/strong> role at our fast-growing, forward thinking mining services company.<\/p>\n\n<p style=\"color:#000000;\"><span style=\"color:#333333;\"> <\/span><\/p>\n<p>This person will function as a <strong>Fuel &amp; Lube Technician<\/strong><span style=\"color:#333333;\">, willingness to do, learn, perform and improve any maintenance task. Tasks will be defined and evolve in all areas of mining operations to ensure preventative maintenance is practiced, repairs, equipment runs in the area of responsibility. This is an opportunity to work as part of the operations team in a safe, productive, and fun environment.<\/span> <span style=\"color:#333333;\"><\/span><\/p>\n\n\n<p><strong>Essential Skills &amp; Knowledge<\/strong><\/p>\n<p style=\"color:#000000;\"><span style=\"color:#333333;\">\u2022 Follow a consistent and regular schedule to perform various types of maintenance on heavy equipment and various pieces of machinery <\/span><\/p>\n<p style=\"color:#000000;\"><span style=\"color:#333333;\">\u2022 Perform minor repairs on equipment using tools, machine tools and measuring instruments <\/span><\/p>\n<p style=\"color:#000000;\"><span style=\"color:#333333;\">\u2022 Conduct oil changes, lubrication of equipment, tire replacements, hose repairs, battery replacements and assorted services <\/span><\/p>\n<p style=\"color:#000000;\"><span style=\"color:#333333;\">\u2022 Operate and test equipment <\/span><\/p>\n<p style=\"color:#000000;\"><span style=\"color:#333333;\">\u2022 Produce detailed service reports and repair logs <\/span><\/p>\n<p style=\"color:#000000;\"><span style=\"color:#333333;\">\u2022 Follow all established procedures and protocols <\/span><\/p>\n<p style=\"color:#000000;\"><span style=\"color:#333333;\">\u2022 Build positive relationships with internal and external teams<\/span><\/p>\n<p style=\"color:#000000;\"><span style=\"color:#333333;\">\u2022 Perform additional duties as assigned<\/span><\/p>\n<p style=\"color:#000000;\"><span style=\"color:#333333;\"> <\/span><\/p>\n<p><strong>Benefits<\/strong><\/p>\n<p style=\"color:#000000;\"><span style=\"color:#333333;\">Turner Mining Group offers a competitive salary, an excellent work culture, career advancement opportunities. Our team offers a benefits program which includes Medical, Dental, Vision, Life, and a 401k with company match. We believe in a work life balance and established paid time off for major holidays.<\/span><\/p>\n<p style=\"color:#000000;\"><span style=\"color:#333333;\"> <\/span><\/p>\n<p>At Turner Mining Group, we encourage and celebrate an inclusive environment for all employees and are proud to be an equal opportunity workplace and affirmative action employer.<\/p>\n<p><\/p>","%category%":"Operations","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/5864776f7e51-fuel-lube-technician-mining","%breezy_id%":"5864776f7e51","%breezy_friendly_id%":"5864776f7e51-fuel-lube-technician-mining","%breezy_created_date%":"2025-09-04T22:39:05.688Z","%breezy_updated_date%":"2025-09-04T22:39:58.915Z","%_wpgmp_location_city%":"Crane","%_wpgmp_location_state%":"TX","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Crane, TX, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"31.3973624","%_wpgmp_metabox_longitude%":"-102.3501419","%rank_math_internal_links_processed%":"1"}},"id":2723,"infowindow_disable":false},{"source":"post","title":"Lead Maintenance Technician","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Lead Maintenance Technician\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Lead Plant Maintenance Technician &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; Reports to: Foreman \u2013 Turner Mining Group Job Description: The Lead Plant Maintenance Technician is&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/lead-maintenance-technician\/\" name=\"Lead Maintenance Technician\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Lead Plant Maintenance Technician &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; Reports to: Foreman \u2013 Turner Mining Group Job Description: The Lead Plant Maintenance Technician is&hellip;","address":"Soda Springs, ID, USA","location":{"lat":"42.6543652","city":"Soda Springs","state":"ID","country":"United States","lng":"-111.6046687","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/lead-maintenance-technician\/","zoom":19,"extra_fields":{"post_excerpt":"Lead Plant Maintenance Technician &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; Reports to: Foreman \u2013 Turner Mining Group Job Description: The Lead Plant Maintenance Technician is&hellip;","post_content":"<p><strong>Lead Plant Maintenance Technician<\/strong>            &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; <\/p>\n<p><strong>Reports to: <\/strong><strong>Foreman \u2013 Turner Mining Group<\/strong><\/p>\n<p><strong>Job Description:<\/strong><\/p>\n<p>The Lead Plant Maintenance Technician is the most skilled plant maintenance position with a focus on developing supervisory leadership skills while maintaining plant equipment within Turner Mining Group. This position will also assist with training other crew members as an SME (Subject Matter Expert), assisting with supervisory duties as a fill-in for the Foreman (as needed), and will oversee quality and efficiency as a strong field leader. The successful candidate must live the Turner Values and be an outward example to others. This position must demonstrate a strong commitment to \u201cSafe Production\u201d through decision making, priorities, and client relations.<\/p>\n<p><strong>Objectives and Contributions:<\/strong><\/p>\n<p>The Lead Plant Maintenance Technician is focused on key aspects that drive communication and safe production while maintaining a high level of efficiency, proactive training metrics, and preventative maintenance awareness requirements. The Lead Plant Maintenance Technician demonstrates safety ownership at a personal level and holds other crew members to the same high standard.&nbsp; The Lead Plant Maintenance Technician also assists in other production support functions as assigned.<\/p>\n<ul><li>Work with employees to ensure a high level of accuracy and engagement on hazard identification and control<\/li><li>Engage crews and leadership to define processes that motivate working towards common goals<\/li><li>Assist with MSHA regulatory training and verify compliance to standards<\/li><li>Live the values as part of a visible daily decision-making process<\/li><li>Audit the crew and the site while focusing on conditions and behaviors that reflect our desire to be the best in the business<\/li><li>Lead training efforts to grow other technicians<\/li><li>Assist with training proficiency audits<\/li><li>Assist with client specific safety needs as required<\/li><li>Support risk assessment processes at various levels of the organization<\/li><li>Holds themselves and others accountable for acting like an owner (taking care of equipment, not wasting resources, using time wisely, and being accountable for conditions and behaviors)<\/li><li>Maintains a high standard of housekeeping (machine and work areas)<\/li><\/ul>\n<p><u>Culture and Communication:<\/u><\/p>\n<ul><li>Can effectively communicate in English (multi-lingual preferred)<\/li><li>Assist with daily lineout meetings and monthly safety topic communications<\/li><li>Assist with site communication programs and processes to ensure timely, specific, and value-added information<\/li><li>Assist with site and project leaders to identify areas of improvement<\/li><li>Work with crews to support proactive near miss reporting<\/li><li>Leads by example (walks the talk)<\/li><\/ul>\n<p><u>Systems:<\/u><\/p>\n<ul><li>Ability to perform quality pre-operation machine inspections<\/li><li>Able to perform quality workplace examination (Per MSHA requirements)<\/li><li>Ability to use electronic filing and reporting systems<\/li><li>Accurately documents 5000-23 and training checklist requirements<\/li><li>Other regulatory &amp; internal \/ external forms as required<\/li><\/ul>\n<p><u>Travel and New Site Development: <\/u><\/p>\n<ul><li>Maintains a valid and insurable driving license<\/li><li>Available to travel on short notice for new site development activities <strong>(Preferred)<\/strong><\/li><li>Available to travel on short notice to support timelines and production requirements at existing sites <strong>(Preferred)<\/strong><\/li><li>Leads new site start-up activities and development of safety tools<\/li><\/ul>\n<p><u>Supervisory \/ Leadership Duties:<\/u><\/p>\n<ul><li>Work directly with site leadership to ensure consistent use of systems, programs, and processes<\/li><li>Assist with crew progression and employee development<\/li><li>Learn and assist with key performance indicators, company targets, and daily progress reporting<\/li><li>Assist in employee timekeeping and production reports<\/li><li>Maintains compliance to Turner Mining Group Policies and Procedures including Fit for Duty requirements<\/li><li>Upholds Code of Conduct requirements<\/li><li>Spend time with Operations, and site supervision to build relationships and develop trust<\/li><li>Assist with development \/ implement processes to reduce and eliminate repeat incidents<\/li><li>Assist in problem-solving including incident investigations, root cause analysis, and corrective action development<\/li><li>Assist in managing maintenance notifications (identification and follow up)<\/li><li>Ability to use site management software <\/li><\/ul>\n<p><u>Time and Interactions:<\/u><\/p>\n<ul><li>The Lead Plant Maintenance Technician must be flexible on shift schedules (days and nights) to assist with training and production needs<\/li><li>The Lead Plant Maintenance Technician will be self-starting, motivated, with a strong desire to be part of a team and to influence improvement. Communication is also critical to keep leadership and site-based personnel in the loop of successes, challenges, and any additional support that may be required<\/li><li>Interacts with client supervision to discuss production challenges, targets, and collaboration between teams<\/li><li>Excellent time management skills<\/li><\/ul>\n<p><u>Qualifications:<\/u><\/p>\n<ul><li>Microsoft Office proficiency <\/li><li>Willingness and ability to adhere to OSHA \/ MSHA regulatory requirements<\/li><li>5-10 years\u2019 experience in mining \/ heavy industry preferred<\/li><li>Working knowledge of safety systems and processes<\/li><li>Appropriate attention to detail required<\/li><li>Strong communication skills<\/li><li>Strong morals and values<\/li><li>Exemplary attendance record<\/li><li>Exemplary safety and disciplinary record<\/li><li>Willingness to be flexible on daily job duty requirements<\/li><li>Maintains a positive outspoken learning attitude<\/li><li>The Lead Plant Maintenance Technician must pass and maintain Turner Mining Group mobile equipment skills qualifications on each piece of the following equipment: <ul><li><strong>Assist vendors on site with major component replacements <\/strong><\/li><li><strong>Assist vendors with minor component replacements <\/strong><\/li><li><strong>Troubleshoot and hydraulic issues \/ failures<\/strong><\/li><li><strong>Maintenance service truck<\/strong><\/li><li><strong>Wear components<\/strong><\/li><li><strong>Minor equipment repairs<\/strong><\/li><li><strong>Preventative maintenance backlog repairs<\/strong><\/li><li><strong>Lubing equipment<\/strong><\/li><li><strong>Equipment fluid level monitoring<\/strong><\/li><li><strong>Washing equipment<\/strong><\/li><li><strong>Skid steer<\/strong><\/li><li><strong>Manlift<\/strong><\/li><li><strong>Telehandler<\/strong><\/li><li><strong>Service Truck<\/strong><\/li><\/ul><\/li><\/ul>\n<p><u><strong>Other Duties:<\/strong><\/u><\/p>\n<ul><li>In addition to the job skills above, there may be requirements for manual tasks to be completed to meet other business needs. Operators in any job duty classification may be required to participate in these additional tasks.<\/li><\/ul>\n<p><u><strong>Benefits<\/strong><\/u><strong><\/strong><br>Turner Mining Group offers a competitive salary, an excellent work culture, and career advancement opportunities. Our team provides a benefits program which includes Medical, Dental, Vision, Life, and a 401k with company match. We believe in a work-life balance and have established paid time off for major holidays.<\/p><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":"Lead Maintenance Technician","post_link":"https:\/\/turnerstaffing.com\/position\/lead-maintenance-technician\/","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%":"Maintenance","%description%":"<p><strong>Lead Plant Maintenance Technician<\/strong>            &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; <\/p>\n<p><strong>Reports to: <\/strong><strong>Foreman \u2013 Turner Mining Group<\/strong><\/p>\n<p><strong>Job Description:<\/strong><\/p>\n<p>The Lead Plant Maintenance Technician is the most skilled plant maintenance position with a focus on developing supervisory leadership skills while maintaining plant equipment within Turner Mining Group. This position will also assist with training other crew members as an SME (Subject Matter Expert), assisting with supervisory duties as a fill-in for the Foreman (as needed), and will oversee quality and efficiency as a strong field leader. The successful candidate must live the Turner Values and be an outward example to others. This position must demonstrate a strong commitment to \u201cSafe Production\u201d through decision making, priorities, and client relations.<\/p>\n<p><strong>Objectives and Contributions:<\/strong><\/p>\n<p>The Lead Plant Maintenance Technician is focused on key aspects that drive communication and safe production while maintaining a high level of efficiency, proactive training metrics, and preventative maintenance awareness requirements. The Lead Plant Maintenance Technician demonstrates safety ownership at a personal level and holds other crew members to the same high standard.&nbsp; The Lead Plant Maintenance Technician also assists in other production support functions as assigned.<\/p>\n<ul><li>Work with employees to ensure a high level of accuracy and engagement on hazard identification and control<\/li><li>Engage crews and leadership to define processes that motivate working towards common goals<\/li><li>Assist with MSHA regulatory training and verify compliance to standards<\/li><li>Live the values as part of a visible daily decision-making process<\/li><li>Audit the crew and the site while focusing on conditions and behaviors that reflect our desire to be the best in the business<\/li><li>Lead training efforts to grow other technicians<\/li><li>Assist with training proficiency audits<\/li><li>Assist with client specific safety needs as required<\/li><li>Support risk assessment processes at various levels of the organization<\/li><li>Holds themselves and others accountable for acting like an owner (taking care of equipment, not wasting resources, using time wisely, and being accountable for conditions and behaviors)<\/li><li>Maintains a high standard of housekeeping (machine and work areas)<\/li><\/ul>\n<p><u>Culture and Communication:<\/u><\/p>\n<ul><li>Can effectively communicate in English (multi-lingual preferred)<\/li><li>Assist with daily lineout meetings and monthly safety topic communications<\/li><li>Assist with site communication programs and processes to ensure timely, specific, and value-added information<\/li><li>Assist with site and project leaders to identify areas of improvement<\/li><li>Work with crews to support proactive near miss reporting<\/li><li>Leads by example (walks the talk)<\/li><\/ul>\n<p><u>Systems:<\/u><\/p>\n<ul><li>Ability to perform quality pre-operation machine inspections<\/li><li>Able to perform quality workplace examination (Per MSHA requirements)<\/li><li>Ability to use electronic filing and reporting systems<\/li><li>Accurately documents 5000-23 and training checklist requirements<\/li><li>Other regulatory &amp; internal \/ external forms as required<\/li><\/ul>\n<p><u>Travel and New Site Development: <\/u><\/p>\n<ul><li>Maintains a valid and insurable driving license<\/li><li>Available to travel on short notice for new site development activities <strong>(Preferred)<\/strong><\/li><li>Available to travel on short notice to support timelines and production requirements at existing sites <strong>(Preferred)<\/strong><\/li><li>Leads new site start-up activities and development of safety tools<\/li><\/ul>\n<p><u>Supervisory \/ Leadership Duties:<\/u><\/p>\n<ul><li>Work directly with site leadership to ensure consistent use of systems, programs, and processes<\/li><li>Assist with crew progression and employee development<\/li><li>Learn and assist with key performance indicators, company targets, and daily progress reporting<\/li><li>Assist in employee timekeeping and production reports<\/li><li>Maintains compliance to Turner Mining Group Policies and Procedures including Fit for Duty requirements<\/li><li>Upholds Code of Conduct requirements<\/li><li>Spend time with Operations, and site supervision to build relationships and develop trust<\/li><li>Assist with development \/ implement processes to reduce and eliminate repeat incidents<\/li><li>Assist in problem-solving including incident investigations, root cause analysis, and corrective action development<\/li><li>Assist in managing maintenance notifications (identification and follow up)<\/li><li>Ability to use site management software <\/li><\/ul>\n<p><u>Time and Interactions:<\/u><\/p>\n<ul><li>The Lead Plant Maintenance Technician must be flexible on shift schedules (days and nights) to assist with training and production needs<\/li><li>The Lead Plant Maintenance Technician will be self-starting, motivated, with a strong desire to be part of a team and to influence improvement. Communication is also critical to keep leadership and site-based personnel in the loop of successes, challenges, and any additional support that may be required<\/li><li>Interacts with client supervision to discuss production challenges, targets, and collaboration between teams<\/li><li>Excellent time management skills<\/li><\/ul>\n<p><u>Qualifications:<\/u><\/p>\n<ul><li>Microsoft Office proficiency <\/li><li>Willingness and ability to adhere to OSHA \/ MSHA regulatory requirements<\/li><li>5-10 years\u2019 experience in mining \/ heavy industry preferred<\/li><li>Working knowledge of safety systems and processes<\/li><li>Appropriate attention to detail required<\/li><li>Strong communication skills<\/li><li>Strong morals and values<\/li><li>Exemplary attendance record<\/li><li>Exemplary safety and disciplinary record<\/li><li>Willingness to be flexible on daily job duty requirements<\/li><li>Maintains a positive outspoken learning attitude<\/li><li>The Lead Plant Maintenance Technician must pass and maintain Turner Mining Group mobile equipment skills qualifications on each piece of the following equipment: <ul><li><strong>Assist vendors on site with major component replacements <\/strong><\/li><li><strong>Assist vendors with minor component replacements <\/strong><\/li><li><strong>Troubleshoot and hydraulic issues \/ failures<\/strong><\/li><li><strong>Maintenance service truck<\/strong><\/li><li><strong>Wear components<\/strong><\/li><li><strong>Minor equipment repairs<\/strong><\/li><li><strong>Preventative maintenance backlog repairs<\/strong><\/li><li><strong>Lubing equipment<\/strong><\/li><li><strong>Equipment fluid level monitoring<\/strong><\/li><li><strong>Washing equipment<\/strong><\/li><li><strong>Skid steer<\/strong><\/li><li><strong>Manlift<\/strong><\/li><li><strong>Telehandler<\/strong><\/li><li><strong>Service Truck<\/strong><\/li><\/ul><\/li><\/ul>\n<p><u><strong>Other Duties:<\/strong><\/u><\/p>\n<ul><li>In addition to the job skills above, there may be requirements for manual tasks to be completed to meet other business needs. Operators in any job duty classification may be required to participate in these additional tasks.<\/li><\/ul>\n<p><u><strong>Benefits<\/strong><\/u><strong><\/strong><br>Turner Mining Group offers a competitive salary, an excellent work culture, and career advancement opportunities. Our team provides a benefits program which includes Medical, Dental, Vision, Life, and a 401k with company match. We believe in a work-life balance and have established paid time off for major holidays.<\/p><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\/0fbf95dbd5c6-lead-maintenance-technician","%breezy_id%":"0fbf95dbd5c6","%breezy_friendly_id%":"0fbf95dbd5c6-lead-maintenance-technician","%breezy_created_date%":"2025-09-04T15:05:11.701Z","%breezy_updated_date%":"2025-09-16T14:52:50.582Z","%_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":2722,"infowindow_disable":false},{"source":"post","title":"Loader Operator &#8211; Mining","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Loader Operator &#8211; Mining\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Turner Mining Group \u2013 Heavy Equipment OperatorTurner Mining Group is seeking an energetic mining professionals who can leverage their mining&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/loader-operator-mining\/\" name=\"Loader Operator &#8211; Mining\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Turner Mining Group \u2013 Heavy Equipment OperatorTurner Mining Group is seeking an energetic mining professionals who can leverage their mining&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\/loader-operator-mining\/","zoom":19,"extra_fields":{"post_excerpt":"Turner Mining Group \u2013 Heavy Equipment OperatorTurner Mining Group is seeking an energetic mining professionals who can leverage their mining&hellip;","post_content":"<p><strong><u>Turner Mining Group \u2013 Heavy Equipment Operator<\/u><\/strong><br>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\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>Operating heavy equipment including <strong>Loaders<\/strong>, 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":"Loader Operator &#8211; Mining","post_link":"https:\/\/turnerstaffing.com\/position\/loader-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%":"","%description%":"<p><strong><u>Turner Mining Group \u2013 Heavy Equipment Operator<\/u><\/strong><br>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\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>Operating heavy equipment including <strong>Loaders<\/strong>, 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\/1b42055dd772-loader-operator-mining","%breezy_id%":"1b42055dd772","%breezy_friendly_id%":"1b42055dd772-loader-operator-mining","%breezy_created_date%":"2025-09-03T22:05:49.406Z","%breezy_updated_date%":"2025-09-03T22:06:27.916Z","%_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":2717,"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 Pendleton,&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/cdl-driver-ready-mix-trucks-3\/\" 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 Pendleton,&hellip;","address":"Pendleton, IN, USA","location":{"lat":"40.0024909","city":"Pendleton","state":"IN","country":"United States","lng":"-85.7456474","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/cdl-driver-ready-mix-trucks-3\/","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 Pendleton,&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>Pendleton, 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 Pendleton, 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-3\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Mid Level","%location_country%":"United States","%location_city%":"Pendleton","%location_state_id%":"IN","%location_state_name%":"Indiana","%location_city_state%":"Pendleton, 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>Pendleton, 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 Pendleton, 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\/1f3a941f0bee-cdl-driver-ready-mix-trucks","%breezy_id%":"1f3a941f0bee","%breezy_friendly_id%":"1f3a941f0bee-cdl-driver-ready-mix-trucks","%breezy_created_date%":"2025-09-03T18:05:14.608Z","%breezy_updated_date%":"2025-09-03T18:06:25.978Z","%_wpgmp_location_city%":"Pendleton","%_wpgmp_location_state%":"IN","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Pendleton, IN, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"40.0024909","%_wpgmp_metabox_longitude%":"-85.7456474","%rank_math_internal_links_processed%":"1"}},"id":2715,"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-2\/\" 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-2\/","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>\n<p>At Turner Mining Group, we encourage and celebrate an inclusive environment for all employees and are proud to be an equal opportunity workplace and affirmative action employer.<\/p>","post_title":"Drill Operator &#8211; Mining","post_link":"https:\/\/turnerstaffing.com\/position\/drill-operator-mining-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%":"","%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>\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\/911035eb6b41-drill-operator-mining","%breezy_id%":"911035eb6b41","%breezy_friendly_id%":"911035eb6b41-drill-operator-mining","%breezy_created_date%":"2025-09-03T22:02:56.298Z","%breezy_updated_date%":"2025-09-03T22:04:14.911Z","%_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":2716,"infowindow_disable":false},{"source":"post","title":"Mine Manager","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Mine Manager\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Turner Mining Group &#8211; Project Manager &#8211; Mining A challenging and rewarding opportunity for a senior project manager with experience&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/mine-manager\/\" name=\"Mine Manager\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Turner Mining Group &#8211; Project Manager &#8211; Mining A challenging and rewarding opportunity for a senior project manager with experience&hellip;","address":"Soda Springs, ID, USA","location":{"lat":"42.6543652","city":"Soda Springs","state":"ID","country":"United States","lng":"-111.6046687","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/mine-manager\/","zoom":19,"extra_fields":{"post_excerpt":"Turner Mining Group &#8211; Project Manager &#8211; Mining A challenging and rewarding opportunity for a senior project manager with experience&hellip;","post_content":"<p><strong><u>Turner Mining Group - Project Manager - Mining<\/u><\/strong><\/p>\n<p>A challenging and rewarding opportunity for a senior project manager with experience in the mining industry!<br><\/p>\n<p>We are looking for a talented Project Manager to lead the development and execution of a large-scale production mining projects. The Project Manager will be responsible for managing the project scope, schedule, budget, quality, safety, and stakeholder relations. The Project Manager will also oversee the engineering, procurement, construction, commissioning, and operation phases of the project.<\/p>\n<p><strong>Responsibilities:<\/strong><br><\/p>\n<ul><li>Develop and implement the project strategy, plan, and governance framework based on data analysis and best practices<\/li><li>Manage the project team and vendors using data-driven tools and metrics<\/li><li>Ensure the project meets the technical, regulatory, and environmental requirements using data validation and verification methods<\/li><li>Monitor and control the project performance, risks, issues, and changes using data visualization and reporting techniques<\/li><li>Report and communicate the project status, progress, and outcomes to the senior management and the client using data storytelling and presentation skills<\/li><li>Ensure the project adheres to the highest standards of health, safety, and quality using data collection and evaluation systems<\/li><li>Facilitate the smooth transition from construction to operation using data integration and automation solutions<\/li><\/ul>\n<p><strong>Qualifications:<\/strong><\/p>\n<ul><li>Bachelor's degree in engineering, project management, or related field<\/li><li>Minimum 10 years of experience in managing large-scale capital projects in the mining industry<\/li><li>Proven track record of delivering projects on time, on budget, and on quality using data-driven approaches<\/li><li>Strong critical thinking, leadership, communication, negotiation, and problem-solving skills with a data-oriented mindset<\/li><li>Ability to work effectively in a fast-paced and dynamic environment with data complexity and uncertainty<\/li><\/ul>\n<p><strong>Benefits:<\/strong><\/p>\n<p>Turner Mining Group offers a competitive salary with additional opportunities to earn, an excellent work culture, career advancement opportunities. Turner Mining Group offers a benefits program which includes Medical, Dental, Vision, Life, and a 401k with company match.&nbsp;<\/p>\n<p>We encourage and celebrate an inclusive environment for all employees and are proud to be an equal opportunity workplace and affirmative action employer.<\/p>","post_title":"Mine Manager","post_link":"https:\/\/turnerstaffing.com\/position\/mine-manager\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Senior","%location_country%":"United States","%location_city%":"Soda Springs","%location_state_id%":"ID","%location_state_name%":"Idaho","%location_city_state%":"Soda Springs, ID","%education%":"","%department%":"Operations","%description%":"<p><strong><u>Turner Mining Group - Project Manager - Mining<\/u><\/strong><\/p>\n<p>A challenging and rewarding opportunity for a senior project manager with experience in the mining industry!<br><\/p>\n<p>We are looking for a talented Project Manager to lead the development and execution of a large-scale production mining projects. The Project Manager will be responsible for managing the project scope, schedule, budget, quality, safety, and stakeholder relations. The Project Manager will also oversee the engineering, procurement, construction, commissioning, and operation phases of the project.<\/p>\n<p><strong>Responsibilities:<\/strong><br><\/p>\n<ul><li>Develop and implement the project strategy, plan, and governance framework based on data analysis and best practices<\/li><li>Manage the project team and vendors using data-driven tools and metrics<\/li><li>Ensure the project meets the technical, regulatory, and environmental requirements using data validation and verification methods<\/li><li>Monitor and control the project performance, risks, issues, and changes using data visualization and reporting techniques<\/li><li>Report and communicate the project status, progress, and outcomes to the senior management and the client using data storytelling and presentation skills<\/li><li>Ensure the project adheres to the highest standards of health, safety, and quality using data collection and evaluation systems<\/li><li>Facilitate the smooth transition from construction to operation using data integration and automation solutions<\/li><\/ul>\n<p><strong>Qualifications:<\/strong><\/p>\n<ul><li>Bachelor's degree in engineering, project management, or related field<\/li><li>Minimum 10 years of experience in managing large-scale capital projects in the mining industry<\/li><li>Proven track record of delivering projects on time, on budget, and on quality using data-driven approaches<\/li><li>Strong critical thinking, leadership, communication, negotiation, and problem-solving skills with a data-oriented mindset<\/li><li>Ability to work effectively in a fast-paced and dynamic environment with data complexity and uncertainty<\/li><\/ul>\n<p><strong>Benefits:<\/strong><\/p>\n<p>Turner Mining Group offers a competitive salary with additional opportunities to earn, an excellent work culture, career advancement opportunities. Turner Mining Group offers a benefits program which includes Medical, Dental, Vision, Life, and a 401k with company match.&nbsp;<\/p>\n<p>We encourage and celebrate an inclusive environment for all employees and are proud to be an equal opportunity workplace and affirmative action employer.<\/p>","%category%":"Operations","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/9fb0daa556d4-mine-manager","%breezy_id%":"9fb0daa556d4","%breezy_friendly_id%":"9fb0daa556d4-mine-manager","%breezy_created_date%":"2025-09-03T12:33:26.801Z","%breezy_updated_date%":"2025-10-14T14:36:27.357Z","%_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":2713,"infowindow_disable":false},{"source":"post","title":"CNC Machinist","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    CNC Machinist\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Position Overview The CNC Machinist will set up and operate conventional, special purpose, CNC, and Numerical Control (NC) machines and&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/cnc-machinist\/\" name=\"CNC Machinist\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Position Overview The CNC Machinist will set up and operate conventional, special purpose, CNC, and Numerical Control (NC) machines and&hellip;","address":"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\/cnc-machinist\/","zoom":19,"extra_fields":{"post_excerpt":"Position Overview The CNC Machinist will set up and operate conventional, special purpose, CNC, and Numerical Control (NC) machines and&hellip;","post_content":"<h1>Position Overview<\/h1>\n<p>The CNC Machinist will set up and operate conventional, special purpose, CNC, and Numerical Control (NC) machines and machining centers to fabricate metallic and nonmetallic parts by performing the essential functions listed below. <\/p>\n<ul><li>This is a non-exempt, hourly position. <\/li><li>Pay commensurate with experience ($30-$50\/hr.).<\/li><li>The CNC machinist will work 10 days on 4 days off schedule, 6:00 am to 5:00 pm.<\/li><\/ul>\n<h1>Essential Functions<\/h1>\n<ul><li>Demonstrate a strong commitment to safe work practices and procedures.<\/li><li><strong>\u00b7        <\/strong>Studies blueprints, sketches, drawings, manuals, specifications, or sample parts to determine dimensions and tolerances of finished workpieces, sequence of operations, and setup requirements. <\/li><li><strong>\u00b7        <\/strong>Measures, marks, and scribes dimensions and reference points on material or workpiece as guides for subsequent machining as necessary. <\/li><li><strong>\u00b7        <\/strong>Selects, aligns, and secures holding fixtures, cutting tools, attachments, accessories, and materials on machines as necessary to machine parts as required.&nbsp; <\/li><li><strong>\u00b7        <\/strong>Calculates and sets controls to regulate machining factors such as speed, feed, coolant flow, and depth and angle of cut, or enters commands to retrieve, input, or edit computerized machine control media according to established guidelines and procedures.&nbsp; <\/li><li><strong>\u00b7        <\/strong>Starts and observes machine operation to detect malfunctions or out-of-tolerance machining and adjusts machine controls or control media as required.&nbsp; <\/li><li><strong>\u00b7        <\/strong>Verifies conformance of finished workpiece to specifications, using measuring and inspection tools as necessary.&nbsp; <\/li><li><strong>\u00b7        <\/strong>Set up and operate the machine on a trial run to verify the accuracy of machine settings or programmed control data.&nbsp; <\/li><li><strong>\u00b7        <\/strong>Performs routine maintenance tasks on machines as required.&nbsp; <\/li><li><strong>\u00b7        <\/strong>Confers with engineers, production personnel, programmers, or others to resolve machining or assembly problems.<\/li><li>Maintain a clean and organized work area and maintain all equipment, to like new appearance, according to maintenance plans and established procedures.<\/li><li>Maintain a positive work atmosphere by acting and communicating in a manner so that you get along with customers, clients, coworkers, and management.<\/li><\/ul>\n<h1>Qualifications<\/h1>\n<ul><li>Associate\u2019s degree (A. A.) from a two-year college or technical school; or two to three years related experience and\/or training; or equivalent combination of education and experience.<\/li><li>Ability to read technical drawings.<\/li><li>Ability to read and interpret documents such as safety rules, operating and maintenance instructions, and procedure manuals.&nbsp; <\/li><li>Ability to write routine reports and correspondence.<\/li><li>Ability to work with mathematical concepts such as portability and statistical inference and fundamentals of plane and solid geometry and trigonometry.&nbsp; <\/li><li>Ability to apply concepts such as fractions, percentages, ratios, and proportions to practical situations.<\/li><li>Ability to solve practical problems and deal with a variety of concrete variables in situations where only limited standardization exists.<\/li><li>Ability to interpret a variety of instructions furnished in written, oral, diagram, or schedule form.<\/li><li>Mazak Mazatrol programming experience preferred. <\/li><li>Must pass a pre-employment physical, drug (including the use of marijuana) and alcohol screening, Motor Vehicle Report (MVR), and additional background screening as required by regulation and\/or industry practice. <\/li><li>Must have a valid driver's license. <\/li><\/ul>","post_title":"CNC Machinist","post_link":"https:\/\/turnerstaffing.com\/position\/cnc-machinist\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Mid Level","%location_country%":"United States","%location_city%":"Tucson","%location_state_id%":"AZ","%location_state_name%":"Arizona","%location_city_state%":"Tucson, AZ","%education%":"Unspecified","%department%":"","%description%":"<h1>Position Overview<\/h1>\n<p>The CNC Machinist will set up and operate conventional, special purpose, CNC, and Numerical Control (NC) machines and machining centers to fabricate metallic and nonmetallic parts by performing the essential functions listed below. <\/p>\n<ul><li>This is a non-exempt, hourly position. <\/li><li>Pay commensurate with experience ($30-$50\/hr.).<\/li><li>The CNC machinist will work 10 days on 4 days off schedule, 6:00 am to 5:00 pm.<\/li><\/ul>\n<h1>Essential Functions<\/h1>\n<ul><li>Demonstrate a strong commitment to safe work practices and procedures.<\/li><li><strong>\u00b7        <\/strong>Studies blueprints, sketches, drawings, manuals, specifications, or sample parts to determine dimensions and tolerances of finished workpieces, sequence of operations, and setup requirements. <\/li><li><strong>\u00b7        <\/strong>Measures, marks, and scribes dimensions and reference points on material or workpiece as guides for subsequent machining as necessary. <\/li><li><strong>\u00b7        <\/strong>Selects, aligns, and secures holding fixtures, cutting tools, attachments, accessories, and materials on machines as necessary to machine parts as required.&nbsp; <\/li><li><strong>\u00b7        <\/strong>Calculates and sets controls to regulate machining factors such as speed, feed, coolant flow, and depth and angle of cut, or enters commands to retrieve, input, or edit computerized machine control media according to established guidelines and procedures.&nbsp; <\/li><li><strong>\u00b7        <\/strong>Starts and observes machine operation to detect malfunctions or out-of-tolerance machining and adjusts machine controls or control media as required.&nbsp; <\/li><li><strong>\u00b7        <\/strong>Verifies conformance of finished workpiece to specifications, using measuring and inspection tools as necessary.&nbsp; <\/li><li><strong>\u00b7        <\/strong>Set up and operate the machine on a trial run to verify the accuracy of machine settings or programmed control data.&nbsp; <\/li><li><strong>\u00b7        <\/strong>Performs routine maintenance tasks on machines as required.&nbsp; <\/li><li><strong>\u00b7        <\/strong>Confers with engineers, production personnel, programmers, or others to resolve machining or assembly problems.<\/li><li>Maintain a clean and organized work area and maintain all equipment, to like new appearance, according to maintenance plans and established procedures.<\/li><li>Maintain a positive work atmosphere by acting and communicating in a manner so that you get along with customers, clients, coworkers, and management.<\/li><\/ul>\n<h1>Qualifications<\/h1>\n<ul><li>Associate\u2019s degree (A. A.) from a two-year college or technical school; or two to three years related experience and\/or training; or equivalent combination of education and experience.<\/li><li>Ability to read technical drawings.<\/li><li>Ability to read and interpret documents such as safety rules, operating and maintenance instructions, and procedure manuals.&nbsp; <\/li><li>Ability to write routine reports and correspondence.<\/li><li>Ability to work with mathematical concepts such as portability and statistical inference and fundamentals of plane and solid geometry and trigonometry.&nbsp; <\/li><li>Ability to apply concepts such as fractions, percentages, ratios, and proportions to practical situations.<\/li><li>Ability to solve practical problems and deal with a variety of concrete variables in situations where only limited standardization exists.<\/li><li>Ability to interpret a variety of instructions furnished in written, oral, diagram, or schedule form.<\/li><li>Mazak Mazatrol programming experience preferred. <\/li><li>Must pass a pre-employment physical, drug (including the use of marijuana) and alcohol screening, Motor Vehicle Report (MVR), and additional background screening as required by regulation and\/or industry practice. <\/li><li>Must have a valid driver's license. <\/li><\/ul>","%category%":"Operations","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/08d567f783a5-cnc-machinist","%breezy_id%":"08d567f783a5","%breezy_friendly_id%":"08d567f783a5-cnc-machinist","%breezy_created_date%":"2025-02-18T17:59:49.317Z","%breezy_updated_date%":"2025-09-03T17:57:57.881Z","%_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":2712,"infowindow_disable":false},{"source":"post","title":"Manual Machinist","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Manual Machinist\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Description Our client is looking for a Manual Machinist to join the team in Tucson, AZ. The Manual Machinist role&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/manual-machinist\/\" name=\"Manual Machinist\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Description Our client is looking for a Manual Machinist to join the team in Tucson, AZ. The Manual Machinist role&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\/manual-machinist\/","zoom":19,"extra_fields":{"post_excerpt":"Description Our client is looking for a Manual Machinist to join the team in Tucson, AZ. The Manual Machinist role&hellip;","post_content":"<p>Description<\/p>\n<p>Our client  is looking for a Manual Machinist to join the team in Tucson, AZ. The Manual Machinist role is responsible to perform basic lathe\/milling operations by utilizing medium size machines including manual lathes\/mills and inspect basic\/routine parts for defects and wear.<\/p>\n<p>Please note: This position requires vocation skills and is not a machine operator or CNC Machinist.<\/p>\n<p>Here's What You'll Do:<\/p>\n<p>\u2022\tPerform milling operations such as drilling, tapping, boring, broaching, and conventional milling and lathe work using various engine lathes including but not limited to horizontal and vertical mills and horizontal boring mills.<\/p>\n<p>\u2022\tUse measuring devices and techniques to ensure proper sizing.<\/p>\n<p>\u2022\tRecord data to produce expected service and\/or design results including sizing and illustrations.<\/p>\n<p>\u2022\tUnderstand materials and their various applications in order to complete job.<\/p>\n<p>\u2022\tUse various hand-held and stationary power and non-power tools including but not limited to band saws, belt sanders, hand grinders, and files to complete job.<\/p>\n<p>\u2022\tLift, tighten, adjust and\/or secure heavy objects in order to perform work and observe safety precautions.<\/p>\n<p>Requirements<\/p>\n<p>Here's What You'll Need:<\/p>\n<p>\u2022\tHigh school diploma or equivalent,.<\/p>\n<p>\u2022\t3 years of machinist experience and\/or machine trades technical schooling<\/p>\n<p>\u2022\tBasic mechanical knowledge required<\/p>\n<p>\u2022\tAbility to read, write, and comprehend basic written and verbal instructions<\/p>\n<p>\u2022\tAbility to understand, perform, and retain various job related training, operational, and safety procedures<\/p>\n<p>\u2022\tAbility to exercise initiative, judgment, and decision making related to routine duties within set company standards<\/p>\n<p>\u2022\tAbility to operate overhead cranes, fork lift trucks, and other equipment<\/p>","post_title":"Manual Machinist","post_link":"https:\/\/turnerstaffing.com\/position\/manual-machinist\/","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>Description<\/p>\n<p>Our client  is looking for a Manual Machinist to join the team in Tucson, AZ. The Manual Machinist role is responsible to perform basic lathe\/milling operations by utilizing medium size machines including manual lathes\/mills and inspect basic\/routine parts for defects and wear.<\/p>\n<p>Please note: This position requires vocation skills and is not a machine operator or CNC Machinist.<\/p>\n<p>Here's What You'll Do:<\/p>\n<p>\u2022\tPerform milling operations such as drilling, tapping, boring, broaching, and conventional milling and lathe work using various engine lathes including but not limited to horizontal and vertical mills and horizontal boring mills.<\/p>\n<p>\u2022\tUse measuring devices and techniques to ensure proper sizing.<\/p>\n<p>\u2022\tRecord data to produce expected service and\/or design results including sizing and illustrations.<\/p>\n<p>\u2022\tUnderstand materials and their various applications in order to complete job.<\/p>\n<p>\u2022\tUse various hand-held and stationary power and non-power tools including but not limited to band saws, belt sanders, hand grinders, and files to complete job.<\/p>\n<p>\u2022\tLift, tighten, adjust and\/or secure heavy objects in order to perform work and observe safety precautions.<\/p>\n<p>Requirements<\/p>\n<p>Here's What You'll Need:<\/p>\n<p>\u2022\tHigh school diploma or equivalent,.<\/p>\n<p>\u2022\t3 years of machinist experience and\/or machine trades technical schooling<\/p>\n<p>\u2022\tBasic mechanical knowledge required<\/p>\n<p>\u2022\tAbility to read, write, and comprehend basic written and verbal instructions<\/p>\n<p>\u2022\tAbility to understand, perform, and retain various job related training, operational, and safety procedures<\/p>\n<p>\u2022\tAbility to exercise initiative, judgment, and decision making related to routine duties within set company standards<\/p>\n<p>\u2022\tAbility to operate overhead cranes, fork lift trucks, and other equipment<\/p>","%category%":"","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/3ea366963b4a-manual-machinist","%breezy_id%":"3ea366963b4a","%breezy_friendly_id%":"3ea366963b4a-manual-machinist","%breezy_created_date%":"2024-09-24T18:00:32.507Z","%breezy_updated_date%":"2025-09-03T18:49:53.268Z","%_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":2711,"infowindow_disable":false},{"source":"post","title":"Heavy Equipment Fuel\/Lube Technician","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Heavy Equipment Fuel\/Lube Technician\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Turner Mining Group &#8211; Heavy Equipment Fuel &amp; Lube Technician Do you love mining? Do you think differently? Are you&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/heavy-equipment-fuel-lube-technician-3\/\" name=\"Heavy Equipment Fuel\/Lube Technician\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Turner Mining Group &#8211; Heavy Equipment Fuel &amp; Lube Technician Do you love mining? Do you think differently? Are you&hellip;","address":"Crane, TX, USA","location":{"lat":"31.3973624","city":"Crane","state":"TX","country":"United States","lng":"-102.3501419","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/heavy-equipment-fuel-lube-technician-3\/","zoom":19,"extra_fields":{"post_excerpt":"Turner Mining Group &#8211; Heavy Equipment Fuel &amp; Lube Technician Do you love mining? Do you think differently? Are you&hellip;","post_content":"<p><strong><u>Turner Mining Group - Heavy Equipment Fuel &amp; Lube Technician<\/u><\/strong><\/p>\n<p style=\"color:#000000\"><span style=\"color:#333333\">Do you love mining? Do you think differently? Are you ready to define the future of this industry?<\/span><\/p>\n<p style=\"color:#000000\"><span style=\"color:#333333\">We\u2019ve been waiting for you! Turner Mining Group is committed to changing the way mining companies do business. We develop our people. We partner with our clients. We believe in win, win, win.<\/span><\/p>\n\n<p>We are looking for a dynamic and talented professional to fill a <strong>Fuel &amp; Lube Technician<\/strong> role at our fast-growing, forward thinking mining services company.<\/p>\n<p style=\"color:#000000\"><span style=\"color:#333333\"> <\/span><\/p>\n<p>This person will function as a <strong>Fuel &amp; Lube Technician<\/strong><span style=\"color:#333333\">, willingness to do, learn, perform and improve any maintenance task. Tasks will be defined and evolve in all areas of mining operations to ensure preventative maintenance is practiced, repairs, equipment runs in the area of responsibility. This is an opportunity to work as part of the operations team in a safe, productive, and fun environment.<\/span> <span style=\"color:#333333\"><\/span><\/p>\n\n\n<p><strong>Essential Skills &amp; Knowledge<\/strong><\/p>\n<p style=\"color:#000000\"><span style=\"color:#333333\">\u2022 Follow a consistent and regular schedule to perform various types of maintenance on heavy equipment and various pieces of machinery <\/span><\/p>\n<p style=\"color:#000000\"><span style=\"color:#333333\">\u2022 Perform minor repairs on equipment using tools, machine tools and measuring instruments <\/span><\/p>\n<p style=\"color:#000000\"><span style=\"color:#333333\">\u2022 Conduct oil changes, lubrication of equipment, tire replacements, hose repairs, battery replacements and assorted services <\/span><\/p>\n<p style=\"color:#000000\"><span style=\"color:#333333\">\u2022 Operate and test equipment <\/span><\/p>\n<p style=\"color:#000000\"><span style=\"color:#333333\">\u2022 Produce detailed service reports and repair logs <\/span><\/p>\n<p style=\"color:#000000\"><span style=\"color:#333333\">\u2022 Follow all established procedures and protocols <\/span><\/p>\n<p style=\"color:#000000\"><span style=\"color:#333333\">\u2022 Build positive relationships with internal and external teams<\/span><\/p>\n<p style=\"color:#000000\"><span style=\"color:#333333\">\u2022 Perform additional duties as assigned<\/span><\/p>\n<p style=\"color:#000000\"><span style=\"color:#333333\"> <\/span><\/p>\n<p><strong>Benefits<\/strong><\/p>\n<p style=\"color:#000000\"><span style=\"color:#333333\">Turner Mining Group offers a competitive salary, an excellent work culture, career advancement opportunities. Our team offers a benefits program which includes Medical, Dental, Vision, Life, and a 401k with company match. We believe in a work life balance and established paid time off for major holidays.<\/span><\/p>\n<p style=\"color:#000000\"><span style=\"color:#333333\"> <\/span><\/p>\n<p>At Turner Mining Group, we encourage and celebrate an inclusive environment for all employees and are proud to be an equal opportunity workplace and affirmative action employer.<\/p>\n<p><\/p>","post_title":"Heavy Equipment Fuel\/Lube Technician","post_link":"https:\/\/turnerstaffing.com\/position\/heavy-equipment-fuel-lube-technician-3\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"","%location_country%":"United States","%location_city%":"Crane","%location_state_id%":"TX","%location_state_name%":"Texas","%location_city_state%":"Crane, TX","%education%":"","%department%":"Equipment","%description%":"<p><strong><u>Turner Mining Group - Heavy Equipment Fuel &amp; Lube Technician<\/u><\/strong><\/p>\n<p style=\"color:#000000;\"><span style=\"color:#333333;\">Do you love mining? Do you think differently? Are you ready to define the future of this industry?<\/span><\/p>\n<p style=\"color:#000000;\"><span style=\"color:#333333;\">We\u2019ve been waiting for you! Turner Mining Group is committed to changing the way mining companies do business. We develop our people. We partner with our clients. We believe in win, win, win.<\/span><\/p>\n\n<p>We are looking for a dynamic and talented professional to fill a <strong>Fuel &amp; Lube Technician<\/strong> role at our fast-growing, forward thinking mining services company.<\/p>\n<p style=\"color:#000000;\"><span style=\"color:#333333;\"> <\/span><\/p>\n<p>This person will function as a <strong>Fuel &amp; Lube Technician<\/strong><span style=\"color:#333333;\">, willingness to do, learn, perform and improve any maintenance task. Tasks will be defined and evolve in all areas of mining operations to ensure preventative maintenance is practiced, repairs, equipment runs in the area of responsibility. This is an opportunity to work as part of the operations team in a safe, productive, and fun environment.<\/span> <span style=\"color:#333333;\"><\/span><\/p>\n\n\n<p><strong>Essential Skills &amp; Knowledge<\/strong><\/p>\n<p style=\"color:#000000;\"><span style=\"color:#333333;\">\u2022 Follow a consistent and regular schedule to perform various types of maintenance on heavy equipment and various pieces of machinery <\/span><\/p>\n<p style=\"color:#000000;\"><span style=\"color:#333333;\">\u2022 Perform minor repairs on equipment using tools, machine tools and measuring instruments <\/span><\/p>\n<p style=\"color:#000000;\"><span style=\"color:#333333;\">\u2022 Conduct oil changes, lubrication of equipment, tire replacements, hose repairs, battery replacements and assorted services <\/span><\/p>\n<p style=\"color:#000000;\"><span style=\"color:#333333;\">\u2022 Operate and test equipment <\/span><\/p>\n<p style=\"color:#000000;\"><span style=\"color:#333333;\">\u2022 Produce detailed service reports and repair logs <\/span><\/p>\n<p style=\"color:#000000;\"><span style=\"color:#333333;\">\u2022 Follow all established procedures and protocols <\/span><\/p>\n<p style=\"color:#000000;\"><span style=\"color:#333333;\">\u2022 Build positive relationships with internal and external teams<\/span><\/p>\n<p style=\"color:#000000;\"><span style=\"color:#333333;\">\u2022 Perform additional duties as assigned<\/span><\/p>\n<p style=\"color:#000000;\"><span style=\"color:#333333;\"> <\/span><\/p>\n<p><strong>Benefits<\/strong><\/p>\n<p style=\"color:#000000;\"><span style=\"color:#333333;\">Turner Mining Group offers a competitive salary, an excellent work culture, career advancement opportunities. Our team offers a benefits program which includes Medical, Dental, Vision, Life, and a 401k with company match. We believe in a work life balance and established paid time off for major holidays.<\/span><\/p>\n<p style=\"color:#000000;\"><span style=\"color:#333333;\"> <\/span><\/p>\n<p>At Turner Mining Group, we encourage and celebrate an inclusive environment for all employees and are proud to be an equal opportunity workplace and affirmative action employer.<\/p>\n<p><\/p>","%category%":"","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/e9a5df43ef43-heavy-equipment-fuel-lube-technician","%breezy_id%":"e9a5df43ef43","%breezy_friendly_id%":"e9a5df43ef43-heavy-equipment-fuel-lube-technician","%breezy_created_date%":"2022-10-27T14:56:27.823Z","%breezy_updated_date%":"2025-09-04T22:44:25.965Z","%_wpgmp_location_city%":"Crane","%_wpgmp_location_state%":"TX","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Crane, TX, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"31.3973624","%_wpgmp_metabox_longitude%":"-102.3501419","%rank_math_internal_links_processed%":"1"}},"id":2710,"infowindow_disable":false},{"source":"post","title":"Dozer Operator","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Dozer Operator\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Turner Mining Group \u2013 Heavy Equipment Operator Do you love mining? Do you think differently? Are you ready to define&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/dozer-operator-4\/\" name=\"Dozer Operator\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Turner Mining Group \u2013 Heavy Equipment Operator Do you love mining? Do you think differently? Are you ready to define&hellip;","address":"Kingman, AZ, USA","location":{"lat":"35.1912977","city":"Kingman","state":"AZ","country":"United States","lng":"-114.0522845","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/dozer-operator-4\/","zoom":19,"extra_fields":{"post_excerpt":"Turner Mining Group \u2013 Heavy Equipment Operator Do you love mining? Do you think differently? Are you ready to define&hellip;","post_content":"<p style=\"color:#000000\"><strong><span style=\"text-decoration:underline\"><span style=\"color:#555555\">Turner Mining Group \u2013 Heavy Equipment Operator<\/span><\/span><\/strong><\/p>\n<p style=\"color:#000000\"><span style=\"color:#333333\">Do you love mining? Do you think differently? Are you ready to define the future of this industry?<\/span><\/p>\n<p style=\"color:#000000\"><span style=\"color:#333333\">We\u2019ve been waiting for you! Turner Mining Group is committed to changing the way mining companies do business. We develop our people. We partner with our clients. We believe in win, win, win.<\/span><\/p>\n<p style=\"color:#000000\"><span style=\"color:#333333\">We are looking for a dynamic and talented mining Heavy Equipment Operators for our fast-growing, forward thinking mining services company headquartered in Bloomington, Indiana with our Operations team headquartered in Salt Lake City, Utah.<\/span><\/p>\n<p style=\"color:#000000\"><span style=\"color:#333333\">Turner Mining Group is seeking an energetic mining professionals who can leverage their mining knowledge to expand upon our fast-growing business, creating best practices for equipment operations to ensure profitable operations.<\/span><\/p>\n<p style=\"color:#000000\"><strong><span style=\"color:#333333\">You<\/span><\/strong><\/p>\n<p style=\"color:#000000\"><span style=\"color:#333333\">You want to work for a services company that is rapidly changing the way the largest materials producers do business. You are motivated by solving problems and partnering with our clients and suppliers. You want to work with great people and enjoy being a part of a strong team. You are a knowledgeable Operator who is not afraid to jump into every detail. You want to be in a place where continuous learning and growth is the norm. You are adaptable and able to juggle multiple initiatives concurrently.<\/span><\/p>\n<p style=\"color:#000000\"><strong><span style=\"color:#555555\">Responsibilities:<\/span><\/strong><\/p>\n<ul><li>Operating heavy equipment including blade, excavators, dozers, haul trucks, and other machines<\/li><li>Performing all pre-shift inspections, some basic maintenance and upkeep<\/li><li>Working with teammates on crew to maximize production while always maintaining our safety rules and regulations.<\/li><\/ul>\n<p style=\"color:#000000\"><strong>Requirements:<\/strong><\/p>\n<ul><li><span style=\"color:#555555\">Safety oriented, awareness of everyone and everything that is around you<\/span><\/li><li><span style=\"color:#555555\">Strong work ethic<\/span><\/li><li><span style=\"color:#555555\">Willingness to learn<\/span><\/li><li><span style=\"color:#555555\">Ability to be flexible and to adapt<\/span><\/li><li><span style=\"color:#555555\">Experience with heavy equipment<\/span><\/li><li><span style=\"color:#555555\">Preferred to have MSHA training<\/span><\/li><\/ul>\n<p><strong>Benefits:<\/strong><\/p>\n<ul><p style=\"color:#000000\"><span style=\"color:#333333\">Turner Mining Group offers a competitive salary, an excellent work culture, career advancement opportunities. Our team offers a benefits program which includes Medical, Dental, Vision, Life, and a 401k with company match.<\/span><\/p><p style=\"color:#000000\"><span style=\"color:#333333\">At Turner Mining Group, we encourage and celebrate an inclusive environment for all employees and are proud to be an equal opportunity workplace and affirmative action employer.<\/span><\/p><\/ul>","post_title":"Dozer Operator","post_link":"https:\/\/turnerstaffing.com\/position\/dozer-operator-4\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"","%location_country%":"United States","%location_city%":"Kingman","%location_state_id%":"AZ","%location_state_name%":"Arizona","%location_city_state%":"Kingman, AZ","%education%":"","%department%":"Construction","%description%":"<p style=\"color:#000000;\"><strong><span style=\"text-decoration:underline;\"><span style=\"color:#555555;\">Turner Mining Group \u2013 Heavy Equipment Operator<\/span><\/span><\/strong><\/p>\n<p style=\"color:#000000;\"><span style=\"color:#333333;\">Do you love mining? Do you think differently? Are you ready to define the future of this industry?<\/span><\/p>\n<p style=\"color:#000000;\"><span style=\"color:#333333;\">We\u2019ve been waiting for you! Turner Mining Group is committed to changing the way mining companies do business. We develop our people. We partner with our clients. We believe in win, win, win.<\/span><\/p>\n<p style=\"color:#000000;\"><span style=\"color:#333333;\">We are looking for a dynamic and talented mining Heavy Equipment Operators for our fast-growing, forward thinking mining services company headquartered in Bloomington, Indiana with our Operations team headquartered in Salt Lake City, Utah.<\/span><\/p>\n<p style=\"color:#000000;\"><span style=\"color:#333333;\">Turner Mining Group is seeking an energetic mining professionals who can leverage their mining knowledge to expand upon our fast-growing business, creating best practices for equipment operations to ensure profitable operations.<\/span><\/p>\n<p style=\"color:#000000;\"><strong><span style=\"color:#333333;\">You<\/span><\/strong><\/p>\n<p style=\"color:#000000;\"><span style=\"color:#333333;\">You want to work for a services company that is rapidly changing the way the largest materials producers do business. You are motivated by solving problems and partnering with our clients and suppliers. You want to work with great people and enjoy being a part of a strong team. You are a knowledgeable Operator who is not afraid to jump into every detail. You want to be in a place where continuous learning and growth is the norm. You are adaptable and able to juggle multiple initiatives concurrently.<\/span><\/p>\n<p style=\"color:#000000;\"><strong><span style=\"color:#555555;\">Responsibilities:<\/span><\/strong><\/p>\n<ul><li>Operating heavy equipment including blade, excavators, dozers, haul trucks, and other machines<\/li><li>Performing all pre-shift inspections, some basic maintenance and upkeep<\/li><li>Working with teammates on crew to maximize production while always maintaining our safety rules and regulations.<\/li><\/ul>\n<p style=\"color:#000000;\"><strong>Requirements:<\/strong><\/p>\n<ul><li><span style=\"color:#555555;\">Safety oriented, awareness of everyone and everything that is around you<\/span><\/li><li><span style=\"color:#555555;\">Strong work ethic<\/span><\/li><li><span style=\"color:#555555;\">Willingness to learn<\/span><\/li><li><span style=\"color:#555555;\">Ability to be flexible and to adapt<\/span><\/li><li><span style=\"color:#555555;\">Experience with heavy equipment<\/span><\/li><li><span style=\"color:#555555;\">Preferred to have MSHA training<\/span><\/li><\/ul>\n<p><strong>Benefits:<\/strong><\/p>\n<ul><p style=\"color:#000000;\"><span style=\"color:#333333;\">Turner Mining Group offers a competitive salary, an excellent work culture, career advancement opportunities. Our team offers a benefits program which includes Medical, Dental, Vision, Life, and a 401k with company match.<\/span><\/p><p style=\"color:#000000;\"><span style=\"color:#333333;\">At Turner Mining Group, we encourage and celebrate an inclusive environment for all employees and are proud to be an equal opportunity workplace and affirmative action employer.<\/span><\/p><\/ul>","%category%":"Operations","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/f9cd3e5e4cda-dozer-operator","%breezy_id%":"f9cd3e5e4cda","%breezy_friendly_id%":"f9cd3e5e4cda-dozer-operator","%breezy_created_date%":"2021-11-16T21:01:07.000Z","%breezy_updated_date%":"2025-09-03T00:08:25.217Z","%_wpgmp_location_city%":"Kingman","%_wpgmp_location_state%":"AZ","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Kingman, AZ, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"35.1912977","%_wpgmp_metabox_longitude%":"-114.0522845","%rank_math_internal_links_processed%":"1"}},"id":2709,"infowindow_disable":false},{"source":"post","title":"Fuel\/Lube Technician &#8211; Mining","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Fuel\/Lube Technician &#8211; Mining\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Turner Mining Group &#8211; Heavy Equipment Fuel &amp; Lube Technician Do you love mining? Do you think differently? Are you&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/fuel-lube-technician-mining\/\" name=\"Fuel\/Lube Technician &#8211; Mining\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Turner Mining Group &#8211; Heavy Equipment Fuel &amp; Lube Technician Do you love mining? Do you think differently? Are you&hellip;","address":"Kingman, AZ, USA","location":{"lat":"35.1912977","city":"Kingman","state":"AZ","country":"United States","lng":"-114.0522845","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/fuel-lube-technician-mining\/","zoom":19,"extra_fields":{"post_excerpt":"Turner Mining Group &#8211; Heavy Equipment Fuel &amp; Lube Technician Do you love mining? Do you think differently? Are you&hellip;","post_content":"<p><strong><u>Turner Mining Group - Heavy Equipment Fuel &amp; Lube Technician<\/u><\/strong><\/p>\n<p style=\"color:#000000\"><span style=\"color:#333333\">Do you love mining? Do you think differently? Are you ready to define the future of this industry?<\/span><\/p>\n<p style=\"color:#000000\"><span style=\"color:#333333\">We\u2019ve been waiting for you! Turner Mining Group is committed to changing the way mining companies do business. We develop our people. We partner with our clients. We believe in win, win, win.<\/span><\/p>\n<p><\/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\"> <\/span><\/p>\n<p>This person will function as a <strong>Fuel &amp; Lube Technician<\/strong><span style=\"color:#333333\">, willingness to do, learn, perform and improve any maintenance task. Tasks will be defined and evolve in all areas of mining operations to ensure preventative maintenance is practiced, repairs, equipment runs in the area of responsibility. This is an opportunity to work as part of the operations team in a safe, productive, and fun environment.<\/span><\/p>\n<p style=\"color:#000000\"> <\/p>\n<p><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 minor repairs on equipment using tools, machine tools and measuring instruments <\/span><\/p>\n<p style=\"color:#000000\"><span style=\"color:#333333\">\u2022 Conduct oil changes, lubrication of equipment, tire replacements, hose repairs, battery replacements and assorted services <\/span><\/p>\n<p style=\"color:#000000\"><span style=\"color:#333333\">\u2022 Operate and test equipment <\/span><\/p>\n<p style=\"color:#000000\"><span style=\"color:#333333\">\u2022 Produce detailed service reports and repair logs <\/span><\/p>\n<p style=\"color:#000000\"><span style=\"color:#333333\">\u2022 Follow all established procedures and protocols <\/span><\/p>\n<p style=\"color:#000000\"><span style=\"color:#333333\">\u2022 Build positive relationships with internal and external teams<\/span><\/p>\n<p style=\"color:#000000\"><span style=\"color:#333333\">\u2022 Perform additional duties as assigned<\/span><\/p>\n<p style=\"color:#000000\"><span style=\"color:#333333\"> <\/span><\/p>\n<p><strong>Benefits<\/strong><\/p>\n<p style=\"color:#000000\"><span style=\"color:#333333\">Turner Mining Group offers a competitive salary, an excellent work culture, career advancement opportunities. Our team offers a benefits program which includes Medical, Dental, Vision, Life, and a 401k with company match. We believe in a work life balance and established paid time off for major holidays.<\/span><\/p>\n<p style=\"color:#000000\"><span style=\"color:#333333\"> <\/span><\/p>\n<p>At Turner Mining Group, we encourage and celebrate an inclusive environment for all employees and are proud to be an equal opportunity workplace and affirmative action employer.<\/p>\n<p><\/p>","post_title":"Fuel\/Lube Technician &#8211; Mining","post_link":"https:\/\/turnerstaffing.com\/position\/fuel-lube-technician-mining\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Associate","%location_country%":"United States","%location_city%":"Kingman","%location_state_id%":"AZ","%location_state_name%":"Arizona","%location_city_state%":"Kingman, AZ","%education%":"Unspecified","%department%":"Maintenance","%description%":"<p><strong><u>Turner Mining Group - Heavy Equipment Fuel &amp; Lube Technician<\/u><\/strong><\/p>\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><\/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;\"> <\/span><\/p>\n<p>This person will function as a <strong>Fuel &amp; Lube Technician<\/strong><span style=\"color:#333333;\">, willingness to do, learn, perform and improve any maintenance task. Tasks will be defined and evolve in all areas of mining operations to ensure preventative maintenance is practiced, repairs, equipment runs in the area of responsibility. This is an opportunity to work as part of the operations team in a safe, productive, and fun environment.<\/span><\/p>\n<p style=\"color:#000000;\"> <\/p>\n<p><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 minor repairs on equipment using tools, machine tools and measuring instruments <\/span><\/p>\n<p style=\"color:#000000;\"><span style=\"color:#333333;\">\u2022 Conduct oil changes, lubrication of equipment, tire replacements, hose repairs, battery replacements and assorted services <\/span><\/p>\n<p style=\"color:#000000;\"><span style=\"color:#333333;\">\u2022 Operate and test equipment <\/span><\/p>\n<p style=\"color:#000000;\"><span style=\"color:#333333;\">\u2022 Produce detailed service reports and repair logs <\/span><\/p>\n<p style=\"color:#000000;\"><span style=\"color:#333333;\">\u2022 Follow all established procedures and protocols <\/span><\/p>\n<p style=\"color:#000000;\"><span style=\"color:#333333;\">\u2022 Build positive relationships with internal and external teams<\/span><\/p>\n<p style=\"color:#000000;\"><span style=\"color:#333333;\">\u2022 Perform additional duties as assigned<\/span><\/p>\n<p style=\"color:#000000;\"><span style=\"color:#333333;\"> <\/span><\/p>\n<p><strong>Benefits<\/strong><\/p>\n<p style=\"color:#000000;\"><span style=\"color:#333333;\">Turner Mining Group offers a competitive salary, an excellent work culture, career advancement opportunities. Our team offers a benefits program which includes Medical, Dental, Vision, Life, and a 401k with company match. We believe in a work life balance and established paid time off for major holidays.<\/span><\/p>\n<p style=\"color:#000000;\"><span style=\"color:#333333;\"> <\/span><\/p>\n<p>At Turner Mining Group, we encourage and celebrate an inclusive environment for all employees and are proud to be an equal opportunity workplace and affirmative action employer.<\/p>\n<p><\/p>","%category%":"Other","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/64979b76ccff-fuel-lube-technician-mining","%breezy_id%":"64979b76ccff","%breezy_friendly_id%":"64979b76ccff-fuel-lube-technician-mining","%breezy_created_date%":"2025-08-27T14:23:25.083Z","%breezy_updated_date%":"2025-08-27T14:24:09.939Z","%_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":2708,"infowindow_disable":false},{"source":"post","title":"Quoting Specialist","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Quoting Specialist\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Primary Purpose: The Quoting Specialist \u2013 Distribution position will prepare accurate quotes for pricingand build estimates by gathering necessary information.&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/quoting-specialist\/\" name=\"Quoting Specialist\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Primary Purpose: The Quoting Specialist \u2013 Distribution position will prepare accurate quotes for pricingand build estimates by gathering necessary information.&hellip;","address":"longview, TX, USA","location":{"lat":"32.5007037","city":"longview","state":"TX","country":"United States","lng":"-94.7404891","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/quoting-specialist\/","zoom":19,"extra_fields":{"post_excerpt":"Primary Purpose: The Quoting Specialist \u2013 Distribution position will prepare accurate quotes for pricingand build estimates by gathering necessary information.&hellip;","post_content":"<p>Primary Purpose: The Quoting Specialist \u2013 Distribution position will prepare accurate quotes for pricing<br>and build estimates by gathering necessary information. This position will quote distributed products.<\/p>\n<p>Primary Responsibilities<\/p>\n<p>\uf0b7 Prepare accurate quotes and estimates.<\/p>\n<p>\uf0b7 Pick template or form based on information available.<\/p>\n<p>\uf0b7 Establish scope of work.<\/p>\n<p>\uf0b7 Own and manage templates for repair work.<\/p>\n<p>\uf0b7 Manage RFQs from Sales, Business Development, Engineering and Field Engineering. Utilize<\/p>\n<p>Approval Matrix as needed.<\/p>\n<p>\uf0b7 Maintain appropriate Distribution product certifications, requirements, knowledge of products.<\/p>\n<p>\uf0b7 Seek Legal\u2019s input on T&amp;Cs where needed.<\/p>\n<p>\uf0b7 Manage RFQ list in progress\/queue.<\/p>\n<p>\uf0b7 Request quotes if needed from Shipping and Buyers.<\/p>\n<p>\uf0b7 Identify billing milestones.<\/p>\n<p>\uf0b7 Execute customer requests or changes to existing POs where appropriate.<\/p>\n<p>\uf0b7 Manage quoted waiting on approval list, following up where needed.<\/p>\n<p>\uf0b7 Gather data on criteria for quotes from internal team members.<\/p>\n<p>\uf0b7 Address concerns promptly and professionally.<\/p>\n<p>\uf0b7 Proactively identify and address areas of concern or improvement.<\/p>\n<p>Knowledge, Skills, and Abilites<\/p>\n<p>\uf0b7 At least 3-5 years of related experience<\/p>\n<p>\uf0b7 Experience with multi-product lines<\/p>\n<p>\uf0b7 Experience with Machining or Fabrication<\/p>\n<p>\uf0b7 Experience with electrical switch gears<\/p>\n<p>\uf0b7 Experience with distributed products<\/p>\n<p>\uf0b7 Strong communication and analytical skills<\/p>\n<p>\uf0b7 High attention to detail<\/p>\n<p>\uf0b7 Provide excellent customer service<\/p>\n<p>\uf0b7 Strong technical proficiency and in-depth knowledge of our products<\/p>\n<p>\uf0b7 Exposure to international markets and sales is beneficial<\/p>\n<p>\uf0b7 Experience with commodity indexes and cost drivers in the industry<\/p>\n<p>\uf0b7 Exposure to value propositions<\/p>","post_title":"Quoting Specialist","post_link":"https:\/\/turnerstaffing.com\/position\/quoting-specialist\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"","%location_country%":"United States","%location_city%":"longview","%location_state_id%":"TX","%location_state_name%":"Texas","%location_city_state%":"longview, TX","%education%":"","%department%":"","%description%":"<p>Primary Purpose: The Quoting Specialist \u2013 Distribution position will prepare accurate quotes for pricing<br>and build estimates by gathering necessary information. This position will quote distributed products.<\/p>\n<p>Primary Responsibilities<\/p>\n<p>\uf0b7 Prepare accurate quotes and estimates.<\/p>\n<p>\uf0b7 Pick template or form based on information available.<\/p>\n<p>\uf0b7 Establish scope of work.<\/p>\n<p>\uf0b7 Own and manage templates for repair work.<\/p>\n<p>\uf0b7 Manage RFQs from Sales, Business Development, Engineering and Field Engineering. Utilize<\/p>\n<p>Approval Matrix as needed.<\/p>\n<p>\uf0b7 Maintain appropriate Distribution product certifications, requirements, knowledge of products.<\/p>\n<p>\uf0b7 Seek Legal\u2019s input on T&amp;Cs where needed.<\/p>\n<p>\uf0b7 Manage RFQ list in progress\/queue.<\/p>\n<p>\uf0b7 Request quotes if needed from Shipping and Buyers.<\/p>\n<p>\uf0b7 Identify billing milestones.<\/p>\n<p>\uf0b7 Execute customer requests or changes to existing POs where appropriate.<\/p>\n<p>\uf0b7 Manage quoted waiting on approval list, following up where needed.<\/p>\n<p>\uf0b7 Gather data on criteria for quotes from internal team members.<\/p>\n<p>\uf0b7 Address concerns promptly and professionally.<\/p>\n<p>\uf0b7 Proactively identify and address areas of concern or improvement.<\/p>\n<p>Knowledge, Skills, and Abilites<\/p>\n<p>\uf0b7 At least 3-5 years of related experience<\/p>\n<p>\uf0b7 Experience with multi-product lines<\/p>\n<p>\uf0b7 Experience with Machining or Fabrication<\/p>\n<p>\uf0b7 Experience with electrical switch gears<\/p>\n<p>\uf0b7 Experience with distributed products<\/p>\n<p>\uf0b7 Strong communication and analytical skills<\/p>\n<p>\uf0b7 High attention to detail<\/p>\n<p>\uf0b7 Provide excellent customer service<\/p>\n<p>\uf0b7 Strong technical proficiency and in-depth knowledge of our products<\/p>\n<p>\uf0b7 Exposure to international markets and sales is beneficial<\/p>\n<p>\uf0b7 Experience with commodity indexes and cost drivers in the industry<\/p>\n<p>\uf0b7 Exposure to value propositions<\/p>","%category%":"","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/a383fc4c4d79-quoting-specialist","%breezy_id%":"a383fc4c4d79","%breezy_friendly_id%":"a383fc4c4d79-quoting-specialist","%breezy_created_date%":"2024-08-29T13:09:56.925Z","%breezy_updated_date%":"2025-08-27T19:52:08.195Z","%_wpgmp_location_city%":"longview","%_wpgmp_location_state%":"TX","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"longview, TX, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"32.5007037","%_wpgmp_metabox_longitude%":"-94.7404891","%rank_math_internal_links_processed%":"1"}},"id":2707,"infowindow_disable":false},{"source":"post","title":"Regional Quoting Specialist","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Regional Quoting Specialist\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Responsibilities &amp; Expectations: \uf0b7 Provide customers with timely and cost-effective solutions in response to all Requests-For-Quote (RFQ) &amp; Requests-For- Information&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/regional-quoting-specialist\/\" name=\"Regional Quoting Specialist\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Responsibilities &amp; Expectations: \uf0b7 Provide customers with timely and cost-effective solutions in response to all Requests-For-Quote (RFQ) &amp; Requests-For- Information&hellip;","address":"Longview, TX, USA","location":{"lat":"32.5007037","city":"Longview","state":"TX","country":"United States","lng":"-94.7404891","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/regional-quoting-specialist\/","zoom":19,"extra_fields":{"post_excerpt":"Responsibilities &amp; Expectations: \uf0b7 Provide customers with timely and cost-effective solutions in response to all Requests-For-Quote (RFQ) &amp; Requests-For- Information&hellip;","post_content":"<p>Responsibilities &amp; Expectations:<\/p>\n<p>\uf0b7 Provide customers with timely and cost-effective solutions in response to all Requests-For-Quote (RFQ) &amp; Requests-For-<\/p>\n<p>Information (RFI) related to motors classified as Motor 1 and Motor 2 products.<\/p>\n<p>\uf0b7 Act as a technical resource to address and resolve inquiries and RFI\u2019s related to distribution products.<\/p>\n<p>\uf0b7 Coordinate and communicate customer needs and expectations with outside sales organization, OEM partners and<\/p>\n<p>operations as required to support customer inquiries, quotes, order processing, shipping notifications, and vendor<\/p>\n<p>management related to Motor 1 and Motor 2 products.<\/p>\n<p>\uf0b7 Responsible for quotation of Motor 1 and Motor 2 repairs and replacement distribution products.<\/p>\n<p>\uf0b7 Responsible for reviewing technical data &amp; requirements of Motor 1 and Motor 2 quote requests, quotes and incoming<\/p>\n<p>purchase orders.<\/p>\n<p>\uf0b7 Responsible for maintaining oversight and maintenance of&nbsp; price matrix in accordance with approved multipliers.<\/p>\n<p>\uf0b7 Responsible for processing customer inquiries related to Motor 1 and Motor 2 products.<\/p>\n<p>\uf0b7 Responsible for tracking regional distribution orders, regional on-time-delivery, and regional vendor KPI\u2019s.<\/p>\n<p>\uf0b7 Responsible for maintaining regional relationships with external suppliers.<\/p>\n<p>\uf0b7 Responsible for maintaining detailed notes within order file and CRM.<\/p>\n<p>\uf0b7 Responsible for coordinating regional product training and product support for outside sales, OEM\u2019s, and customers.<\/p>\n<p>\uf0b7 Responsible for tracking regional joint-call (2x2) efforts with approved OEM\u2019s and regional vendor partners.<\/p>\n<p>\uf0b7 Responsible for monitoring and managing regional KPI's with regional vendor partners.<\/p>\n<p>\uf0b7 Other duties as requested by supervisor or management.<\/p>\n<p><br><\/p><p>Qualifications and competencies:<\/p>\n<p>\uf0b7 Sharp analytical thinking and reasoning abilities.<\/p>\n<p>\uf0b7 Proficient with Microsoft Office.<\/p>\n<p>\uf0b7 Ability to analyze and interpret data and take appropriate action.<\/p>\n<p>\uf0b7 Must be extremely detail-oriented with sound problem-solving skills.<\/p>\n<p>\uf0b7 Ability to prioritize and maintain a high degree of organization.<\/p>\n<p>\uf0b7 Excellent time management.<\/p>\n<p>\uf0b7 Communicates effectively and with purpose \u2013 capable of providing clear, timely, concise communications.<\/p>\n<p>\uf0b7 Possess excellent written and verbal skills.<\/p>\n<p>\uf0b7 Prefer 5+ years of technical sales, inside sales, customer service or similar experience.<\/p>\n<p>\uf0b7 Experience in motor repair, industrial product distribution or related industry.<\/p>\n<p>\uf0b7 Experience interpreting and understanding dimensional drawings.<\/p>\n<p>\uf0b7 Value teamwork and accountability. Must work well with others, take responsibility, serve others, and deliver on<\/p>\n<p>commitments in a timely fashion.<\/p>\n<p>\uf0b7 Proactive, innovative, and thrives in an ever-changing fast-paced role.<\/p>","post_title":"Regional Quoting Specialist","post_link":"https:\/\/turnerstaffing.com\/position\/regional-quoting-specialist\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Mid Level","%location_country%":"United States","%location_city%":"Longview","%location_state_id%":"TX","%location_state_name%":"Texas","%location_city_state%":"Longview, TX","%education%":"Unspecified","%department%":"","%description%":"<p>Responsibilities &amp; Expectations:<\/p>\n<p>\uf0b7 Provide customers with timely and cost-effective solutions in response to all Requests-For-Quote (RFQ) &amp; Requests-For-<\/p>\n<p>Information (RFI) related to motors classified as Motor 1 and Motor 2 products.<\/p>\n<p>\uf0b7 Act as a technical resource to address and resolve inquiries and RFI\u2019s related to distribution products.<\/p>\n<p>\uf0b7 Coordinate and communicate customer needs and expectations with outside sales organization, OEM partners and<\/p>\n<p>operations as required to support customer inquiries, quotes, order processing, shipping notifications, and vendor<\/p>\n<p>management related to Motor 1 and Motor 2 products.<\/p>\n<p>\uf0b7 Responsible for quotation of Motor 1 and Motor 2 repairs and replacement distribution products.<\/p>\n<p>\uf0b7 Responsible for reviewing technical data &amp; requirements of Motor 1 and Motor 2 quote requests, quotes and incoming<\/p>\n<p>purchase orders.<\/p>\n<p>\uf0b7 Responsible for maintaining oversight and maintenance of&nbsp; price matrix in accordance with approved multipliers.<\/p>\n<p>\uf0b7 Responsible for processing customer inquiries related to Motor 1 and Motor 2 products.<\/p>\n<p>\uf0b7 Responsible for tracking regional distribution orders, regional on-time-delivery, and regional vendor KPI\u2019s.<\/p>\n<p>\uf0b7 Responsible for maintaining regional relationships with external suppliers.<\/p>\n<p>\uf0b7 Responsible for maintaining detailed notes within order file and CRM.<\/p>\n<p>\uf0b7 Responsible for coordinating regional product training and product support for outside sales, OEM\u2019s, and customers.<\/p>\n<p>\uf0b7 Responsible for tracking regional joint-call (2x2) efforts with approved OEM\u2019s and regional vendor partners.<\/p>\n<p>\uf0b7 Responsible for monitoring and managing regional KPI's with regional vendor partners.<\/p>\n<p>\uf0b7 Other duties as requested by supervisor or management.<\/p>\n<p><br><\/p><p>Qualifications and competencies:<\/p>\n<p>\uf0b7 Sharp analytical thinking and reasoning abilities.<\/p>\n<p>\uf0b7 Proficient with Microsoft Office.<\/p>\n<p>\uf0b7 Ability to analyze and interpret data and take appropriate action.<\/p>\n<p>\uf0b7 Must be extremely detail-oriented with sound problem-solving skills.<\/p>\n<p>\uf0b7 Ability to prioritize and maintain a high degree of organization.<\/p>\n<p>\uf0b7 Excellent time management.<\/p>\n<p>\uf0b7 Communicates effectively and with purpose \u2013 capable of providing clear, timely, concise communications.<\/p>\n<p>\uf0b7 Possess excellent written and verbal skills.<\/p>\n<p>\uf0b7 Prefer 5+ years of technical sales, inside sales, customer service or similar experience.<\/p>\n<p>\uf0b7 Experience in motor repair, industrial product distribution or related industry.<\/p>\n<p>\uf0b7 Experience interpreting and understanding dimensional drawings.<\/p>\n<p>\uf0b7 Value teamwork and accountability. Must work well with others, take responsibility, serve others, and deliver on<\/p>\n<p>commitments in a timely fashion.<\/p>\n<p>\uf0b7 Proactive, innovative, and thrives in an ever-changing fast-paced role.<\/p>","%category%":"Operations","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/6d873a4cd54f-regional-quoting-specialist","%breezy_id%":"6d873a4cd54f","%breezy_friendly_id%":"6d873a4cd54f-regional-quoting-specialist","%breezy_created_date%":"2025-08-22T15:26:14.963Z","%breezy_updated_date%":"2025-08-22T15:26:51.938Z","%_wpgmp_location_city%":"Longview","%_wpgmp_location_state%":"TX","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Longview, TX, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"32.5007037","%_wpgmp_metabox_longitude%":"-94.7404891","%rank_math_internal_links_processed%":"1"}},"id":2704,"infowindow_disable":false},{"source":"post","title":"Loader\/Excavator Operator &#8211; Mining","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Loader\/Excavator 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\/excavator-operator-mining\/\" name=\"Loader\/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 Do you love mining? Do you think differently? Are you ready to define&hellip;","address":"Kingman, AZ, USA","location":{"lat":"35.1912977","city":"Kingman","state":"AZ","country":"United States","lng":"-114.0522845","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/excavator-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 style=\"color:#000000\"><span style=\"color:#333333\"><strong><\/strong><\/span><strong><span style=\"text-decoration:underline\"><span style=\"color:#555555\">Turner Mining Group \u2013 Heavy Equipment Operator<\/span><\/span><\/strong><\/p>\n<p style=\"color:#000000\"><span style=\"color:#333333\">Do you love mining? Do you think differently? Are you ready to define the future of this industry?<\/span><\/p>\n<p style=\"color:#000000\"><span style=\"color:#333333\">We\u2019ve been waiting for you! Turner Mining Group is committed to changing the way mining companies do business. We develop our people. We partner with our clients. We believe in win, win, win.<\/span><\/p>\n<p style=\"color:#000000\"><span style=\"color:#333333\">We are looking for a dynamic and talented mining Heavy Equipment Operators for our fast-growing, forward thinking mining services company headquartered in Bloomington, Indiana with our Operations team headquartered in Salt Lake City, Utah.<\/span><\/p>\n<p style=\"color:#000000\"><span style=\"color:#333333\">Turner Mining Group is seeking an energetic mining professionals who can leverage their mining knowledge to expand upon our fast-growing business, creating best practices for equipment operations to ensure profitable operations.<\/span><\/p>\n<p style=\"color:#000000\"><strong><span style=\"color:#333333\">You<\/span><\/strong><\/p>\n<p style=\"color:#000000\"><span style=\"color:#333333\">You want to work for a services company that is rapidly changing the way the largest materials producers do business. You are motivated by solving problems and partnering with our clients and suppliers. You want to work with great people and enjoy being a part of a strong team. You are a knowledgeable Operator who is not afraid to jump into every detail. You want to be in a place where continuous learning and growth is the norm. You are adaptable and able to juggle multiple initiatives concurrently.<\/span><\/p>\n<p style=\"color:#000000\"><strong><span style=\"color:#555555\">Responsibilities:<\/span><\/strong><\/p>\n<ul><li>Operating heavy equipment including blade, excavators, dozers, haul trucks, and other machines<\/li><li>Performing all pre-shift inspections, some basic maintenance and upkeep<\/li><li>Working with teammates on crew to maximize production while always maintaining our safety rules and regulations.<\/li><\/ul>\n<p style=\"color:#000000\"><strong>Requirements:<\/strong><\/p>\n<ul><li><span style=\"color:#555555\">Safety oriented, awareness of everyone and everything that is around you<\/span><\/li><li><span style=\"color:#555555\">Strong work ethic<\/span><\/li><li><span style=\"color:#555555\">Willingness to learn<\/span><\/li><li><span style=\"color:#555555\">Ability to be flexible and to adapt<\/span><\/li><li><span style=\"color:#555555\">Experience with heavy equipment<\/span><\/li><li><span style=\"color:#555555\">Preferred to have MSHA training<\/span><\/li><\/ul>\n<p><strong>Benefits:<\/strong><\/p>\n<ul><p style=\"color:#000000\"><span style=\"color:#333333\">Turner Mining Group offers a competitive salary, an excellent work culture, career advancement opportunities. Our team offers a benefits program which includes Medical, Dental, Vision, Life, and a 401k with company match.<\/span><\/p><p style=\"color:#000000\"><span style=\"color:#333333\">At Turner Mining Group, we encourage and celebrate an inclusive environment for all employees and are proud to be an equal opportunity workplace and affirmative action employer.<\/span><\/p><\/ul>\n<p style=\"color:#000000\"><span style=\"color:#333333\">&nbsp;<\/span><\/p>","post_title":"Loader\/Excavator Operator &#8211; Mining","post_link":"https:\/\/turnerstaffing.com\/position\/excavator-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%":"","%department%":"Construction","%description%":"<p style=\"color:#000000;\"><span style=\"color:#333333;\"><strong><\/strong><\/span><strong><span style=\"text-decoration:underline;\"><span style=\"color:#555555;\">Turner Mining Group \u2013 Heavy Equipment Operator<\/span><\/span><\/strong><\/p>\n<p style=\"color:#000000;\"><span style=\"color:#333333;\">Do you love mining? Do you think differently? Are you ready to define the future of this industry?<\/span><\/p>\n<p style=\"color:#000000;\"><span style=\"color:#333333;\">We\u2019ve been waiting for you! Turner Mining Group is committed to changing the way mining companies do business. We develop our people. We partner with our clients. We believe in win, win, win.<\/span><\/p>\n<p style=\"color:#000000;\"><span style=\"color:#333333;\">We are looking for a dynamic and talented mining Heavy Equipment Operators for our fast-growing, forward thinking mining services company headquartered in Bloomington, Indiana with our Operations team headquartered in Salt Lake City, Utah.<\/span><\/p>\n<p style=\"color:#000000;\"><span style=\"color:#333333;\">Turner Mining Group is seeking an energetic mining professionals who can leverage their mining knowledge to expand upon our fast-growing business, creating best practices for equipment operations to ensure profitable operations.<\/span><\/p>\n<p style=\"color:#000000;\"><strong><span style=\"color:#333333;\">You<\/span><\/strong><\/p>\n<p style=\"color:#000000;\"><span style=\"color:#333333;\">You want to work for a services company that is rapidly changing the way the largest materials producers do business. You are motivated by solving problems and partnering with our clients and suppliers. You want to work with great people and enjoy being a part of a strong team. You are a knowledgeable Operator who is not afraid to jump into every detail. You want to be in a place where continuous learning and growth is the norm. You are adaptable and able to juggle multiple initiatives concurrently.<\/span><\/p>\n<p style=\"color:#000000;\"><strong><span style=\"color:#555555;\">Responsibilities:<\/span><\/strong><\/p>\n<ul><li>Operating heavy equipment including blade, excavators, dozers, haul trucks, and other machines<\/li><li>Performing all pre-shift inspections, some basic maintenance and upkeep<\/li><li>Working with teammates on crew to maximize production while always maintaining our safety rules and regulations.<\/li><\/ul>\n<p style=\"color:#000000;\"><strong>Requirements:<\/strong><\/p>\n<ul><li><span style=\"color:#555555;\">Safety oriented, awareness of everyone and everything that is around you<\/span><\/li><li><span style=\"color:#555555;\">Strong work ethic<\/span><\/li><li><span style=\"color:#555555;\">Willingness to learn<\/span><\/li><li><span style=\"color:#555555;\">Ability to be flexible and to adapt<\/span><\/li><li><span style=\"color:#555555;\">Experience with heavy equipment<\/span><\/li><li><span style=\"color:#555555;\">Preferred to have MSHA training<\/span><\/li><\/ul>\n<p><strong>Benefits:<\/strong><\/p>\n<ul><p style=\"color:#000000;\"><span style=\"color:#333333;\">Turner Mining Group offers a competitive salary, an excellent work culture, career advancement opportunities. Our team offers a benefits program which includes Medical, Dental, Vision, Life, and a 401k with company match.<\/span><\/p><p style=\"color:#000000;\"><span style=\"color:#333333;\">At Turner Mining Group, we encourage and celebrate an inclusive environment for all employees and are proud to be an equal opportunity workplace and affirmative action employer.<\/span><\/p><\/ul>\n<p style=\"color:#000000;\"><span style=\"color:#333333;\">&nbsp;<\/span><\/p>","%category%":"Operations","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/49cabfbc3545-loader-excavator-operator-mining","%breezy_id%":"49cabfbc3545","%breezy_friendly_id%":"49cabfbc3545-loader-excavator-operator-mining","%breezy_created_date%":"2021-11-16T21:04:28.000Z","%breezy_updated_date%":"2025-08-25T18:07:58.691Z","%_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":2690,"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":"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":"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-20T15:24:40.184Z","%_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-10-16T13:41:42.073Z","%_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":"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":"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-10-09T13:33:18.441Z","%_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 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-08-28T14:37:34.897Z","%_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.9391746","city":"Midland-Odessa","state":"TX","country":"United States","lng":"-102.2522487","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.9391746","%_wpgmp_metabox_longitude%":"-102.2522487","%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-08-25T18:25:53.240Z","%_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":"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":"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":"Wright, WY, USA","location":{"lat":"43.7518832","city":"Wright","state":"WY","country":"United States","lng":"-105.4913345","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/mining-electrician\/","zoom":19,"extra_fields":{"post_excerpt":"This role will carry out preventive and breakdown maintenance to fixed and mobile plant in an open cut environments. Duties&hellip;","post_content":"<p>This role will carry out preventive and breakdown maintenance to fixed and mobile plant in an open cut environments.<\/p>\n<p><\/p>\n<p>Duties will include:<\/p>\n<ul><li>Visibly support and champion our client's Mission and Values<\/li><li>Act in accordance with and adhere to Safety as a Way of Life Management System<\/li><\/ul>\n<ul><li>Inspect work area and plant for hazards, damage and defects<\/li><li>Examine drawings or specifications to determine work methods, sequence of activities or manufacture of components<\/li><li>Diagnose faults or breakdowns<\/li><li>Estimate time and materials required to complete jobs<\/li><li>Raise orders for materials<\/li><li>Undertake repairs or component changeouts as required<\/li><li>Clean and maintain tools and work area<\/li><li>Train other personnel or apprentices (if required)<\/li><li>Ensure activities comply with safety, environmental and statutory requirements<\/li><li>Other duties as assigned by the company<\/li><\/ul>\n<p><\/p>\n<p><strong>The Lifestyle:<\/strong><\/p>\n<p>This position may require the necessity to work weekends, holidays, or another shift as deemed necessary.&nbsp;&nbsp;&nbsp;<br><\/p>\n\n\n<p><\/p>\n<p><strong>About you:<\/strong><\/p>\n<ul><li>Three years\u2019 experience performing electrical maintenance work in a heavy industrial environment or mine site is preferred.<\/li><li>Ability to solve problems and troubleshoot situations arising in the pit area as needed.<\/li><li>Ability to work in all types of weather conditions and at different times of day.<\/li><li>Ability to work a flexible schedule as required by business need.<\/li><li>Ability to work rotating shifts, weekends and overtime when required.<\/li><li>High School Degree or GED Equivalent required<\/li><\/ul>\n<p><\/p>\n<p><strong>Physical Requirements - Surface:<\/strong><\/p>\n<ul><li>Must have the ability to stand for up to 4 hours per shift<\/li><li>Must have the ability to be seated for up to 4 hours to operate equipment or vehicles<\/li><li>Must have the ability to work from elevated positions, walk\/climb up and down stairs\/steps and climb on and off equipment and ladders<\/li><li>Must have the ability to wear required protective footwear, hearing and eye protection, and other personal protective equipment as required by Company and MSHA<\/li><li>Must have the ability to perform repetitive hand and wrist motions (push, pull, twist, handle), and have rapid reflex movements of the arms and legs and good hand to eye coordination<\/li><li>Must have the ability to lift\/raise 10 - 50 lbs. without mechanical assistance frequently during the course of work shift&nbsp;<\/li><li>Must have the ability to work in extreme conditions, including but not limited to changing weather conditions, dust, mud, varying levels of noise from low to high, varying degrees of light and dark, in and around artificial light and in a confined work area<\/li><li>The job requires that you be able to work various shifts (required shifts include days, evenings and nights with rotating schedules, weekends and holidays&nbsp;&nbsp;&nbsp;<\/li><\/ul>","post_title":"Mining Electrician","post_link":"https:\/\/turnerstaffing.com\/position\/mining-electrician\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Mid Level","%location_country%":"United States","%location_city%":"Wright","%location_state_id%":"WY","%location_state_name%":"Wyoming","%location_city_state%":"Wright, WY","%education%":"High School or equivalent","%department%":"","%description%":"<p>This role will carry out preventive and breakdown maintenance to fixed and mobile plant in an open cut environments.<\/p>\n<p><\/p>\n<p>Duties will include:<\/p>\n<ul><li>Visibly support and champion our client's Mission and Values<\/li><li>Act in accordance with and adhere to Safety as a Way of Life Management System<\/li><\/ul>\n<ul><li>Inspect work area and plant for hazards, damage and defects<\/li><li>Examine drawings or specifications to determine work methods, sequence of activities or manufacture of components<\/li><li>Diagnose faults or breakdowns<\/li><li>Estimate time and materials required to complete jobs<\/li><li>Raise orders for materials<\/li><li>Undertake repairs or component changeouts as required<\/li><li>Clean and maintain tools and work area<\/li><li>Train other personnel or apprentices (if required)<\/li><li>Ensure activities comply with safety, environmental and statutory requirements<\/li><li>Other duties as assigned by the company<\/li><\/ul>\n<p><\/p>\n<p><strong>The Lifestyle:<\/strong><\/p>\n<p>This position may require the necessity to work weekends, holidays, or another shift as deemed necessary.&nbsp;&nbsp;&nbsp;<br><\/p>\n\n\n<p><\/p>\n<p><strong>About you:<\/strong><\/p>\n<ul><li>Three years\u2019 experience performing electrical maintenance work in a heavy industrial environment or mine site is preferred.<\/li><li>Ability to solve problems and troubleshoot situations arising in the pit area as needed.<\/li><li>Ability to work in all types of weather conditions and at different times of day.<\/li><li>Ability to work a flexible schedule as required by business need.<\/li><li>Ability to work rotating shifts, weekends and overtime when required.<\/li><li>High School Degree or GED Equivalent required<\/li><\/ul>\n<p><\/p>\n<p><strong>Physical Requirements - Surface:<\/strong><\/p>\n<ul><li>Must have the ability to stand for up to 4 hours per shift<\/li><li>Must have the ability to be seated for up to 4 hours to operate equipment or vehicles<\/li><li>Must have the ability to work from elevated positions, walk\/climb up and down stairs\/steps and climb on and off equipment and ladders<\/li><li>Must have the ability to wear required protective footwear, hearing and eye protection, and other personal protective equipment as required by Company and MSHA<\/li><li>Must have the ability to perform repetitive hand and wrist motions (push, pull, twist, handle), and have rapid reflex movements of the arms and legs and good hand to eye coordination<\/li><li>Must have the ability to lift\/raise 10 - 50 lbs. without mechanical assistance frequently during the course of work shift&nbsp;<\/li><li>Must have the ability to work in extreme conditions, including but not limited to changing weather conditions, dust, mud, varying levels of noise from low to high, varying degrees of light and dark, in and around artificial light and in a confined work area<\/li><li>The job requires that you be able to work various shifts (required shifts include days, evenings and nights with rotating schedules, weekends and holidays&nbsp;&nbsp;&nbsp;<\/li><\/ul>","%category%":"Operations","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/a05737fef3a3-mining-electrician","%breezy_id%":"a05737fef3a3","%breezy_friendly_id%":"a05737fef3a3-mining-electrician","%breezy_created_date%":"2024-11-19T19:27:43.964Z","%breezy_updated_date%":"2025-09-08T17:58:41.387Z","%_wpgmp_location_city%":"Wright","%_wpgmp_location_state%":"WY","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Wright, WY, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"43.7518832","%_wpgmp_metabox_longitude%":"-105.4913345","%rank_math_internal_links_processed%":"1"}},"id":2573,"infowindow_disable":false},{"source":"post","title":"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":"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":"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":"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-08-27T17:42:45.262Z","%_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":"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":"32.0545019","city":"Carlisle","state":"IN","country":"United States","lng":"76.7942403","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%":"32.0545019","%_wpgmp_metabox_longitude%":"76.7942403","%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-09-08T15:56:37.747Z","%_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-09-08T13:56:00.183Z","%_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":"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":"32.0545019","city":"Carlisle","state":"IN","country":"United States","lng":"76.7942403","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%":"32.0545019","%_wpgmp_metabox_longitude%":"76.7942403","%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-09-03T00:08:06.552Z","%_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-09-03T00:08:07.807Z","%_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":"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-09-15T16:48:06.259Z","%_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-09-15T16:48:11.116Z","%_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-08-26T01:20:30.867Z","%_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-20T15:27:10.096Z","%_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":"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-09-09T19:29:07.538Z","%_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-09-08T15:44:36.412Z","%_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-08-27T18:04:53.424Z","%_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":"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-10-09T17:38:37.686Z","%_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-10-06T19:30:57.074Z","%_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":"Drill Operator &#8211; Mining","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Drill Operator &#8211; Mining\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Job Title: Drill Operator Location:&nbsp;Kingman,&nbsp;AZ Company:&nbsp;Turner Mining Group Position Type:&nbsp;Full-Time Salary:&nbsp;Competitive, based on experience Job Overview: Turner Mining&nbsp;Group is seeking&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/drill-operator-mining\/\" name=\"Drill Operator &#8211; Mining\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Job Title: Drill Operator Location:&nbsp;Kingman,&nbsp;AZ Company:&nbsp;Turner Mining Group Position Type:&nbsp;Full-Time Salary:&nbsp;Competitive, based on experience Job Overview: Turner Mining&nbsp;Group is seeking&hellip;","address":"Kingman, AZ, USA","location":{"lat":"35.1912977","city":"Kingman","state":"AZ","country":"United States","lng":"-114.0522845","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/drill-operator-mining\/","zoom":19,"extra_fields":{"post_excerpt":"Job Title: Drill Operator Location:&nbsp;Kingman,&nbsp;AZ Company:&nbsp;Turner Mining Group Position Type:&nbsp;Full-Time Salary:&nbsp;Competitive, based on experience Job Overview: Turner Mining&nbsp;Group is seeking&hellip;","post_content":"<h3><strong>Job Title: Drill Operator<\/strong><\/h3>\n<p><strong>Location:<\/strong>&nbsp;Kingman,&nbsp;AZ<\/p>\n<p><strong>Company:<\/strong>&nbsp;Turner Mining Group<\/p>\n<p><strong>Position Type:<\/strong>&nbsp;Full-Time<\/p>\n<p><strong>Salary:<\/strong>&nbsp;Competitive, based on experience<\/p>\n<h4><strong>Job Overview:<\/strong><\/h4>\n<p>Turner Mining&nbsp;Group is seeking experienced Drill Operators to join our mining team in Kingman, AZ. The ideal candidates will have hands-on experience operating drilling equipment. The role involves operating drilling rigs to support mining operations and ensuring that all drilling activities are performed safely and efficiently.<\/p>\n<h4><strong>Key Responsibilities:<\/strong><\/h4>\n<ul><li>Operate drilling rigs in a mining environment.<\/li><li>Perform pre-operational checks and routine maintenance on drilling equipment to ensure optimal performance.<\/li><li>Accurately interpret drill plans and follow specifications for drilling operations.<\/li><li>Monitor the drilling process, adjusting as necessary to ensure safety and efficiency.<\/li><li>Collaborate with other team members to coordinate drilling activities and support overall mining operations.<\/li><li>Maintain accurate records of drilling operations, including depth, time, and any issues encountered.<\/li><li>Ensure compliance with all safety regulations and company policies.<\/li><li>Troubleshoot and resolve operational issues as they arise.<\/li><li>Assist in training and mentoring less experienced drill operators.<\/li><li>Perform additional tasks as assigned by supervisors.<\/li><\/ul>\n<h4><strong>Qualifications:<\/strong><\/h4>\n<ul><li>High school diploma or equivalent.<\/li><li>Proven experience as a drill operator.<\/li><li>Strong understanding of drilling techniques and equipment maintenance.<\/li><li>Ability to read and interpret drilling plans, blueprints, and technical manuals.<\/li><li>Excellent physical condition, with the ability to work in various weather conditions.<\/li><li>Strong problem-solving skills and attention to detail.<\/li><li>Good communication and teamwork abilities.<\/li><li>Commitment to maintaining a safe work environment.<\/li><li>Valid driver\u2019s license and reliable transportation.<\/li><\/ul>\n<h4><strong>Preferred Qualifications:<\/strong><\/h4>\n<ul><li>Certification or specialized training in drilling operations.<\/li><li>Previous experience in a mining environment.<\/li><li>Familiarity with drilling software and technology.<\/li><\/ul>\n<h4><strong>Benefits:<\/strong><\/h4>\n<ul><li>Competitive salary and benefits package.<\/li><li>Opportunities for career advancement and professional development.<\/li><li>Comprehensive health, dental, and vision insurance.<\/li><li>Retirement savings plan with company match.<\/li><li>Paid time off and holidays.<\/li><li>Supportive and collaborative work environment.<\/li><\/ul><p>At Turner Mining Group, we encourage and celebrate an inclusive environment for all employees and are proud to be an equal opportunity workplace and affirmative action employer.<\/p>","post_title":"Drill Operator &#8211; Mining","post_link":"https:\/\/turnerstaffing.com\/position\/drill-operator-mining\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"","%location_country%":"United States","%location_city%":"Kingman","%location_state_id%":"AZ","%location_state_name%":"Arizona","%location_city_state%":"Kingman, AZ","%education%":"Unspecified","%department%":"Operations","%description%":"<h3><strong>Job Title: Drill Operator<\/strong><\/h3>\n<p><strong>Location:<\/strong>&nbsp;Kingman,&nbsp;AZ<\/p>\n<p><strong>Company:<\/strong>&nbsp;Turner Mining Group<\/p>\n<p><strong>Position Type:<\/strong>&nbsp;Full-Time<\/p>\n<p><strong>Salary:<\/strong>&nbsp;Competitive, based on experience<\/p>\n<h4><strong>Job Overview:<\/strong><\/h4>\n<p>Turner Mining&nbsp;Group is seeking experienced Drill Operators to join our mining team in Kingman, AZ. The ideal candidates will have hands-on experience operating drilling equipment. The role involves operating drilling rigs to support mining operations and ensuring that all drilling activities are performed safely and efficiently.<\/p>\n<h4><strong>Key Responsibilities:<\/strong><\/h4>\n<ul><li>Operate drilling rigs in a mining environment.<\/li><li>Perform pre-operational checks and routine maintenance on drilling equipment to ensure optimal performance.<\/li><li>Accurately interpret drill plans and follow specifications for drilling operations.<\/li><li>Monitor the drilling process, adjusting as necessary to ensure safety and efficiency.<\/li><li>Collaborate with other team members to coordinate drilling activities and support overall mining operations.<\/li><li>Maintain accurate records of drilling operations, including depth, time, and any issues encountered.<\/li><li>Ensure compliance with all safety regulations and company policies.<\/li><li>Troubleshoot and resolve operational issues as they arise.<\/li><li>Assist in training and mentoring less experienced drill operators.<\/li><li>Perform additional tasks as assigned by supervisors.<\/li><\/ul>\n<h4><strong>Qualifications:<\/strong><\/h4>\n<ul><li>High school diploma or equivalent.<\/li><li>Proven experience as a drill operator.<\/li><li>Strong understanding of drilling techniques and equipment maintenance.<\/li><li>Ability to read and interpret drilling plans, blueprints, and technical manuals.<\/li><li>Excellent physical condition, with the ability to work in various weather conditions.<\/li><li>Strong problem-solving skills and attention to detail.<\/li><li>Good communication and teamwork abilities.<\/li><li>Commitment to maintaining a safe work environment.<\/li><li>Valid driver\u2019s license and reliable transportation.<\/li><\/ul>\n<h4><strong>Preferred Qualifications:<\/strong><\/h4>\n<ul><li>Certification or specialized training in drilling operations.<\/li><li>Previous experience in a mining environment.<\/li><li>Familiarity with drilling software and technology.<\/li><\/ul>\n<h4><strong>Benefits:<\/strong><\/h4>\n<ul><li>Competitive salary and benefits package.<\/li><li>Opportunities for career advancement and professional development.<\/li><li>Comprehensive health, dental, and vision insurance.<\/li><li>Retirement savings plan with company match.<\/li><li>Paid time off and holidays.<\/li><li>Supportive and collaborative work environment.<\/li><\/ul><p>At Turner Mining Group, we encourage and celebrate an inclusive environment for all employees and are proud to be an equal opportunity workplace and affirmative action employer.<\/p>","%category%":"Operations","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/dd6894e17546-drill-operator-mining","%breezy_id%":"dd6894e17546","%breezy_friendly_id%":"dd6894e17546-drill-operator-mining","%breezy_created_date%":"2025-02-24T21:05:14.005Z","%breezy_updated_date%":"2025-09-04T14:04:11.748Z","%_wpgmp_location_city%":"Kingman","%_wpgmp_location_state%":"AZ","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Kingman, AZ, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"35.1912977","%_wpgmp_metabox_longitude%":"-114.0522845","%rank_math_internal_links_processed%":"1"}},"id":2198,"infowindow_disable":false},{"source":"post","title":"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-10-03T19:50:59.606Z","%_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-09-16T17:14:30.393Z","%_wpgmp_location_city%":"Gabbs","%_wpgmp_location_state%":"NV","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Gabbs, NV, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"38.8690562","%_wpgmp_metabox_longitude%":"-117.9228819","%rank_math_internal_links_processed%":"1"}},"id":1953,"infowindow_disable":false},{"source":"post","title":"Maintenance Mechanic","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Maintenance Mechanic\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Position Overview We are currently hiring experienced, full-time, hourly shop and field mechanics. &nbsp;These positions diagnose, adjust, repair, fabricate, and&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/maintenance-mechanic-hydraulics\/\" name=\"Maintenance Mechanic\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Position Overview We are currently hiring experienced, full-time, hourly shop and field mechanics. &nbsp;These positions diagnose, adjust, repair, fabricate, and&hellip;","address":"Phoenix, AZ, USA","location":{"lat":"33.4482948","city":"Phoenix","state":"AZ","country":"United States","lng":"-112.0725488","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/maintenance-mechanic-hydraulics\/","zoom":19,"extra_fields":{"post_excerpt":"Position Overview We are currently hiring experienced, full-time, hourly shop and field mechanics. &nbsp;These positions diagnose, adjust, repair, fabricate, and&hellip;","post_content":"<h1>Position Overview<\/h1>\n<p>We are currently hiring experienced, full-time, hourly shop and field mechanics. &nbsp;These positions diagnose, adjust, repair, fabricate, and overhaul mobile mechanical, hydraulic, and pneumatic parts, and equipment\/vehicles. Excellent welding and fabricating experience preferred.<\/p>\n<p><\/p>\n<ul><li>For field mechanics, travel is required.<\/li><li>Mechanics&nbsp;can work a 10 days on\/4 days off, or 9 days on\/5 days off schedule.&nbsp;<\/li><\/ul>\n<p><\/p>\n<h1>Essential Functions<\/h1>\n<ul><li>Demonstrate a strong commitment to safe work practices and procedures.<\/li><li>Repair and replace damaged or worn parts.<\/li><li>Operate and inspect machines or heavy equipment to diagnose defects.<\/li><li>Diagnose faults or malfunctions to determine required repairs, using engine diagnostic equipment such as computerized test equipment and calibration devices.<\/li><li>Dismantle and reassemble heavy equipment using hoists and hand tools.<\/li><li>Clean, lubricate, and perform other routine maintenance work on equipment and vehicles.<\/li><li>Examine parts for damage or excessive wear using micrometers and gauges.<\/li><li>Schedule maintenance for industrial machines and equipment and keep equipment service records.<\/li><li>Read and understand operating manuals, blueprints, and technical drawings.<\/li><li>Weld or solder broken parts and structural members using electric or gas welders and soldering tools.<\/li><li>Fabricate needed parts or items as required.<\/li><li>Exhibit a strong work ethic with the drive and desire to learn and perform tasks efficiently.&nbsp;<\/li><li>Maintain effective and collaborative workplace relationships, treating others with dignity and respect.<\/li><\/ul>\n<p><\/p>\n<h1>Qualifications<\/h1>\n<ul><li>Must pass a pre-employment physical, drug (including the use of marijuana) and alcohol screening, Motor Vehicle Report (MVR), and additional background screening as required by regulation and\/or industry practice.&nbsp;<\/li><li>Must have a valid driver's license.&nbsp;<\/li><li>Must be willing to travel and work in remote locations, outside, and in all weather conditions (heat and cold)<\/li><li>Experience repairing and maintaining mechanical equipment.<\/li><li>Experience running, maneuvering, navigating, or driving vehicles or mechanized equipment, such as forklifts, passenger and heavy equipment, and vehicles.<\/li><li>Experience analyzing information and evaluating results to choose the best solution and solve problems.<\/li><li>Experience inspecting equipment, structures, or materials to identify the cause of errors or other problems or defects.<\/li><li>Ability to understand and carry out general instructions in standard situations.<\/li><li>Ability to make decisions with a general understanding of procedures and company policies to achieve set results and deadlines.<\/li><li>Ability to multi-task and work under aggressive deadline pressure.<\/li><li>Ability to maintain a positive outlook when challenged with difficult or unknown problems.<\/li><li>Possess good time management skills.<\/li><\/ul>","post_title":"Maintenance Mechanic","post_link":"https:\/\/turnerstaffing.com\/position\/maintenance-mechanic-hydraulics\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"","%location_country%":"United States","%location_city%":"Phoenix","%location_state_id%":"AZ","%location_state_name%":"Arizona","%location_city_state%":"Phoenix, AZ","%education%":"","%department%":"","%description%":"<h1>Position Overview<\/h1>\n<p>We are currently hiring experienced, full-time, hourly shop and field mechanics. &nbsp;These positions diagnose, adjust, repair, fabricate, and overhaul mobile mechanical, hydraulic, and pneumatic parts, and equipment\/vehicles. Excellent welding and fabricating experience preferred.<\/p>\n<p><\/p>\n<ul><li>For field mechanics, travel is required.<\/li><li>Mechanics&nbsp;can work a 10 days on\/4 days off, or 9 days on\/5 days off schedule.&nbsp;<\/li><\/ul>\n<p><\/p>\n<h1>Essential Functions<\/h1>\n<ul><li>Demonstrate a strong commitment to safe work practices and procedures.<\/li><li>Repair and replace damaged or worn parts.<\/li><li>Operate and inspect machines or heavy equipment to diagnose defects.<\/li><li>Diagnose faults or malfunctions to determine required repairs, using engine diagnostic equipment such as computerized test equipment and calibration devices.<\/li><li>Dismantle and reassemble heavy equipment using hoists and hand tools.<\/li><li>Clean, lubricate, and perform other routine maintenance work on equipment and vehicles.<\/li><li>Examine parts for damage or excessive wear using micrometers and gauges.<\/li><li>Schedule maintenance for industrial machines and equipment and keep equipment service records.<\/li><li>Read and understand operating manuals, blueprints, and technical drawings.<\/li><li>Weld or solder broken parts and structural members using electric or gas welders and soldering tools.<\/li><li>Fabricate needed parts or items as required.<\/li><li>Exhibit a strong work ethic with the drive and desire to learn and perform tasks efficiently.&nbsp;<\/li><li>Maintain effective and collaborative workplace relationships, treating others with dignity and respect.<\/li><\/ul>\n<p><\/p>\n<h1>Qualifications<\/h1>\n<ul><li>Must pass a pre-employment physical, drug (including the use of marijuana) and alcohol screening, Motor Vehicle Report (MVR), and additional background screening as required by regulation and\/or industry practice.&nbsp;<\/li><li>Must have a valid driver's license.&nbsp;<\/li><li>Must be willing to travel and work in remote locations, outside, and in all weather conditions (heat and cold)<\/li><li>Experience repairing and maintaining mechanical equipment.<\/li><li>Experience running, maneuvering, navigating, or driving vehicles or mechanized equipment, such as forklifts, passenger and heavy equipment, and vehicles.<\/li><li>Experience analyzing information and evaluating results to choose the best solution and solve problems.<\/li><li>Experience inspecting equipment, structures, or materials to identify the cause of errors or other problems or defects.<\/li><li>Ability to understand and carry out general instructions in standard situations.<\/li><li>Ability to make decisions with a general understanding of procedures and company policies to achieve set results and deadlines.<\/li><li>Ability to multi-task and work under aggressive deadline pressure.<\/li><li>Ability to maintain a positive outlook when challenged with difficult or unknown problems.<\/li><li>Possess good time management skills.<\/li><\/ul>","%category%":"","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/6eefa39a14e4-maintenance-mechanic","%breezy_id%":"6eefa39a14e4","%breezy_friendly_id%":"6eefa39a14e4-maintenance-mechanic","%breezy_created_date%":"2024-11-01T17:33:37.970Z","%breezy_updated_date%":"2025-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.4482948","%_wpgmp_metabox_longitude%":"-112.0725488","%rank_math_internal_links_processed%":"1"}},"id":1919,"infowindow_disable":false},{"source":"post","title":"Maintenance Mechanic &#8211; Hydraulics","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Maintenance Mechanic &#8211; Hydraulics\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Position Overview We are currently hiring experienced, full-time, hourly shop and field mechanics. &nbsp;These positions diagnose, adjust, repair, fabricate, and&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/maintenance-mechanic-hydraulics-2\/\" name=\"Maintenance Mechanic &#8211; Hydraulics\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Position Overview We are currently hiring experienced, full-time, hourly shop and field mechanics. &nbsp;These positions diagnose, adjust, repair, fabricate, and&hellip;","address":"Elko, NV, USA","location":{"lat":"40.8436459","city":"Elko","state":"NV","country":"United States","lng":"-115.7526187","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/maintenance-mechanic-hydraulics-2\/","zoom":19,"extra_fields":{"post_excerpt":"Position Overview We are currently hiring experienced, full-time, hourly shop and field mechanics. &nbsp;These positions diagnose, adjust, repair, fabricate, and&hellip;","post_content":"<h1>Position Overview<\/h1>\n<p>We are currently hiring experienced, full-time, hourly shop and field mechanics. &nbsp;These positions diagnose, adjust, repair, fabricate, and overhaul mobile mechanical, hydraulic, and pneumatic parts, and equipment\/vehicles. Excellent welding and fabricating experience preferred.<\/p>\n<p><\/p>\n<ul><li>For field mechanics, travel is required.<\/li><li>Mechanics&nbsp;can work a 10 days on\/4 days off, or 9 days on\/5 days off schedule.&nbsp;<\/li><\/ul>\n<p><\/p>\n<h1>Essential Functions<\/h1>\n<ul><li>Demonstrate a strong commitment to safe work practices and procedures.<\/li><li>Repair and replace damaged or worn parts.<\/li><li>Operate and inspect machines or heavy equipment to diagnose defects.<\/li><li>Diagnose faults or malfunctions to determine required repairs, using engine diagnostic equipment such as computerized test equipment and calibration devices.<\/li><li>Dismantle and reassemble heavy equipment using hoists and hand tools.<\/li><li>Clean, lubricate, and perform other routine maintenance work on equipment and vehicles.<\/li><li>Examine parts for damage or excessive wear using micrometers and gauges.<\/li><li>Schedule maintenance for industrial machines and equipment and keep equipment service records.<\/li><li>Read and understand operating manuals, blueprints, and technical drawings.<\/li><li>Weld or solder broken parts and structural members using electric or gas welders and soldering tools.<\/li><li>Fabricate needed parts or items as required.<\/li><li>Exhibit a strong work ethic with the drive and desire to learn and perform tasks efficiently.&nbsp;<\/li><li>Maintain effective and collaborative workplace relationships, treating others with dignity and respect.<\/li><\/ul>\n<p><\/p>\n<h1>Qualifications<\/h1>\n<ul><li>Must pass a pre-employment physical, drug (including the use of marijuana) and alcohol screening, Motor Vehicle Report (MVR), and additional background screening as required by regulation and\/or industry practice.&nbsp;<\/li><li>Must have a valid driver's license.&nbsp;<\/li><li>Must be willing to travel and work in remote locations, outside, and in all weather conditions (heat and cold)<\/li><li>Experience repairing and maintaining mechanical equipment.<\/li><li>Experience running, maneuvering, navigating, or driving vehicles or mechanized equipment, such as forklifts, passenger and heavy equipment, and vehicles.<\/li><li>Experience analyzing information and evaluating results to choose the best solution and solve problems.<\/li><li>Experience inspecting equipment, structures, or materials to identify the cause of errors or other problems or defects.<\/li><li>Ability to understand and carry out general instructions in standard situations.<\/li><li>Ability to make decisions with a general understanding of procedures and company policies to achieve set results and deadlines.<\/li><li>Ability to multi-task and work under aggressive deadline pressure.<\/li><li>Ability to maintain a positive outlook when challenged with difficult or unknown problems.<\/li><li>Possess good time management skills.<\/li><\/ul>","post_title":"Maintenance Mechanic &#8211; Hydraulics","post_link":"https:\/\/turnerstaffing.com\/position\/maintenance-mechanic-hydraulics-2\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"","%location_country%":"United States","%location_city%":"Elko","%location_state_id%":"NV","%location_state_name%":"Nevada","%location_city_state%":"Elko, NV","%education%":"","%department%":"","%description%":"<h1>Position Overview<\/h1>\n<p>We are currently hiring experienced, full-time, hourly shop and field mechanics. &nbsp;These positions diagnose, adjust, repair, fabricate, and overhaul mobile mechanical, hydraulic, and pneumatic parts, and equipment\/vehicles. Excellent welding and fabricating experience preferred.<\/p>\n<p><\/p>\n<ul><li>For field mechanics, travel is required.<\/li><li>Mechanics&nbsp;can work a 10 days on\/4 days off, or 9 days on\/5 days off schedule.&nbsp;<\/li><\/ul>\n<p><\/p>\n<h1>Essential Functions<\/h1>\n<ul><li>Demonstrate a strong commitment to safe work practices and procedures.<\/li><li>Repair and replace damaged or worn parts.<\/li><li>Operate and inspect machines or heavy equipment to diagnose defects.<\/li><li>Diagnose faults or malfunctions to determine required repairs, using engine diagnostic equipment such as computerized test equipment and calibration devices.<\/li><li>Dismantle and reassemble heavy equipment using hoists and hand tools.<\/li><li>Clean, lubricate, and perform other routine maintenance work on equipment and vehicles.<\/li><li>Examine parts for damage or excessive wear using micrometers and gauges.<\/li><li>Schedule maintenance for industrial machines and equipment and keep equipment service records.<\/li><li>Read and understand operating manuals, blueprints, and technical drawings.<\/li><li>Weld or solder broken parts and structural members using electric or gas welders and soldering tools.<\/li><li>Fabricate needed parts or items as required.<\/li><li>Exhibit a strong work ethic with the drive and desire to learn and perform tasks efficiently.&nbsp;<\/li><li>Maintain effective and collaborative workplace relationships, treating others with dignity and respect.<\/li><\/ul>\n<p><\/p>\n<h1>Qualifications<\/h1>\n<ul><li>Must pass a pre-employment physical, drug (including the use of marijuana) and alcohol screening, Motor Vehicle Report (MVR), and additional background screening as required by regulation and\/or industry practice.&nbsp;<\/li><li>Must have a valid driver's license.&nbsp;<\/li><li>Must be willing to travel and work in remote locations, outside, and in all weather conditions (heat and cold)<\/li><li>Experience repairing and maintaining mechanical equipment.<\/li><li>Experience running, maneuvering, navigating, or driving vehicles or mechanized equipment, such as forklifts, passenger and heavy equipment, and vehicles.<\/li><li>Experience analyzing information and evaluating results to choose the best solution and solve problems.<\/li><li>Experience inspecting equipment, structures, or materials to identify the cause of errors or other problems or defects.<\/li><li>Ability to understand and carry out general instructions in standard situations.<\/li><li>Ability to make decisions with a general understanding of procedures and company policies to achieve set results and deadlines.<\/li><li>Ability to multi-task and work under aggressive deadline pressure.<\/li><li>Ability to maintain a positive outlook when challenged with difficult or unknown problems.<\/li><li>Possess good time management skills.<\/li><\/ul>","%category%":"","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/763cd94c1a7b-maintenance-mechanic-hydraulics","%breezy_id%":"763cd94c1a7b","%breezy_friendly_id%":"763cd94c1a7b-maintenance-mechanic-hydraulics","%breezy_created_date%":"2024-11-01T17:38:12.191Z","%breezy_updated_date%":"2025-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-09-15T16:48:02.733Z","%_wpgmp_location_city%":"Elko","%_wpgmp_location_state%":"NV","%_wpgmp_location_country%":"United States","%_wpgmp_location_address%":"Elko, NV, USA","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_latitude%":"40.8436459","%_wpgmp_metabox_longitude%":"-115.7526187","%rank_math_internal_links_processed%":"1"}},"id":1780,"infowindow_disable":false},{"source":"post","title":"Field Service Mechanic","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Field Service Mechanic\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Mechanic I-IV Do you want to work with the best people and equipment in the industry? Are you tired of&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/field-service-mechanic\/\" name=\"Field Service Mechanic\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Mechanic I-IV Do you want to work with the best people and equipment in the industry? Are you tired of&hellip;","address":"Phoenix, AZ, USA","location":{"lat":"33.4482948","city":"Phoenix","state":"AZ","country":"United States","lng":"-112.0725488","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/field-service-mechanic\/","zoom":19,"extra_fields":{"post_excerpt":"Mechanic I-IV Do you want to work with the best people and equipment in the industry? Are you tired of&hellip;","post_content":"<p><strong>Mechanic I-IV<\/strong><\/p>\n<p>Do you want to work with the best people and equipment in the industry? Are you tired of not having the parts and support needed to do your job? We offer clean, modern workspaces, fully stocked parts rooms, advanced repair and fabrication equipment, and knowledgeable, supportive leadership that will help you progress in your career.<\/p>\n<p>Our greatest asset is our team of hardworking professionals \u2013 especially our reliable and experienced maintenance crews. If you value integrity, an honest day\u2019s work, and professionalism, you will feel right at home.<\/p>\n<p>In addition to respect and appreciation for a job well done, we offer industry-leading equipment, monthly tooling allowance, competitive compensation, and travel per diem paired with a comprehensive Employee Benefit Program, including things like company-paid insurance premiums (where we pay 100% of the employee-only insurance premiums), 401(k) match, and paid time off.  <\/p>\n<p>Position Overview<\/p>\n<p>We are currently hiring experienced, full-time, hourly shop and field mechanics.  These positions diagnose, adjust, repair, fabricate, and overhaul mobile mechanical, hydraulic, and pneumatic parts, and equipment\/vehicles. Excellent welding and fabricating experience preferred.<\/p>\n<ul>\n <li>For      field mechanics, travel is required.<\/li>\n <li>Mechanics can      work a 10 days on\/4 days off, or 9 days on\/5 days off schedule. <\/li>\n<\/ul>\n<p>Essential Functions<\/p>\n<ul>\n <li>Demonstrate      a strong commitment to safe work practices and procedures.<\/li>\n <li>Repair      and replace damaged or worn parts.<\/li>\n <li>Operate      and inspect machines or heavy equipment to diagnose defects.<\/li>\n <li>Diagnose      faults or malfunctions to determine required repairs, using engine      diagnostic equipment such as computerized test equipment and calibration      devices.<\/li>\n <li>Dismantle      and reassemble heavy equipment using hoists and hand tools.<\/li>\n <li>Clean,      lubricate, and perform other routine maintenance work on equipment and      vehicles.<\/li>\n <li>Examine      parts for damage or excessive wear using micrometers and gauges.<\/li>\n <li>Schedule      maintenance for industrial machines and equipment and keep equipment      service records.<\/li>\n <li>Read      and understand operating manuals, blueprints, and technical drawings.<\/li>\n <li>Weld      or solder broken parts and structural members using electric or gas      welders and soldering tools.<\/li>\n <li>Fabricate      needed parts or items as required.<\/li>\n <li>Exhibit      a strong work ethic with the drive and desire to learn and perform tasks      efficiently. <\/li>\n <li>Maintain      effective and collaborative workplace relationships, treating others with      dignity and respect.<\/li>\n<\/ul>\n<p>Qualifications<\/p>\n<ul>\n <li>Must      pass a pre-employment physical, drug (including the use of marijuana) and      alcohol screening, Motor Vehicle Report (MVR), and additional background      screening as required by regulation and\/or industry practice. <\/li>\n <li>Must      have a valid driver's license. <\/li>\n <li>Must      be willing to travel and work in remote locations, outside, and in all      weather conditions (heat and cold)<\/li>\n <li>Experience      repairing and maintaining mechanical equipment.<\/li>\n <li>Experience      running, maneuvering, navigating, or driving vehicles or mechanized      equipment, such as forklifts, passenger and heavy equipment, and vehicles.<\/li>\n <li>Experience      analyzing information and evaluating results to choose the best solution      and solve problems.<\/li>\n <li>Experience      inspecting equipment, structures, or materials to identify the cause of      errors or other problems or defects.<\/li>\n <li>Ability      to understand and carry out general instructions in standard situations.<\/li>\n <li>Ability      to make decisions with a general understanding of procedures and company      policies to achieve set results and deadlines.<\/li>\n <li>Ability      to multi-task and work under aggressive deadline pressure.<\/li>\n <li>Ability      to maintain a positive outlook when challenged with difficult or unknown      problems.<\/li>\n <li>Possess      good time management skills.<\/li>\n<\/ul>\n<p>Typical Pay Schedule (Based upon experience)<\/p>\n<p>Mechanic I - $25\/hr.<\/p>\n<ul>\n <li>One      (1) to two (2) years\u2019 experience as a hydraulic and electrical mechanic. <\/li>\n <li>New      graduates will be considered if trained on heavy equipment with      hydraulics. <\/li>\n<\/ul>\n<p>Mechanic II - $30-$40\/hr.<\/p>\n<ul>\n <li>Three (3) to five (5) years\u2019 experience as a      hydraulic and electrical mechanic.<\/li>\n<\/ul>\n<p>Mechanic III - $40-$55\/hr. (Pay determination based on shop position or field position)<\/p>\n<ul>\n <li>Six      (6) years\u2019 experience as a hydraulic and electrical mechanic. <\/li>\n <li>Experienced      drilling support equipment, such as mud systems, generators, and      compressors preferred.<\/li>\n <li>Ability      to work independently in the field without the daily support from the      Maintenance Supervisor.<\/li>\n<\/ul>\n<p>Mechanic IV - $40-65\/hr. (Pay determination based on shop position or field position)<\/p>\n<ul>\n <li>Six      (6) plus years\u2019 experience as a hydraulic and electrical mechanic or      strong knowledge with the ability to complete all aspects of the field      mechanic position without support from the Maintenance Supervisor. <\/li>\n <li>Experienced      drilling support equipment, such as mud systems, generators, and      compressors preferred.<\/li>\n<\/ul>","post_title":"Field Service Mechanic","post_link":"https:\/\/turnerstaffing.com\/position\/field-service-mechanic\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"","%location_country%":"United States","%location_city%":"Phoenix","%location_state_id%":"AZ","%location_state_name%":"Arizona","%location_city_state%":"Phoenix, AZ","%education%":"","%department%":"","%description%":"<p><strong>Mechanic I-IV<\/strong><\/p>\n<p>Do you want to work with the best people and equipment in the industry? Are you tired of not having the parts and support needed to do your job? We offer clean, modern workspaces, fully stocked parts rooms, advanced repair and fabrication equipment, and knowledgeable, supportive leadership that will help you progress in your career.<\/p>\n<p>Our greatest asset is our team of hardworking professionals \u2013 especially our reliable and experienced maintenance crews. If you value integrity, an honest day\u2019s work, and professionalism, you will feel right at home.<\/p>\n<p>In addition to respect and appreciation for a job well done, we offer industry-leading equipment, monthly tooling allowance, competitive compensation, and travel per diem paired with a comprehensive Employee Benefit Program, including things like company-paid insurance premiums (where we pay 100% of the employee-only insurance premiums), 401(k) match, and paid time off.  <\/p>\n<p>Position Overview<\/p>\n<p>We are currently hiring experienced, full-time, hourly shop and field mechanics.  These positions diagnose, adjust, repair, fabricate, and overhaul mobile mechanical, hydraulic, and pneumatic parts, and equipment\/vehicles. Excellent welding and fabricating experience preferred.<\/p>\n<ul>\n <li>For      field mechanics, travel is required.<\/li>\n <li>Mechanics can      work a 10 days on\/4 days off, or 9 days on\/5 days off schedule. <\/li>\n<\/ul>\n<p>Essential Functions<\/p>\n<ul>\n <li>Demonstrate      a strong commitment to safe work practices and procedures.<\/li>\n <li>Repair      and replace damaged or worn parts.<\/li>\n <li>Operate      and inspect machines or heavy equipment to diagnose defects.<\/li>\n <li>Diagnose      faults or malfunctions to determine required repairs, using engine      diagnostic equipment such as computerized test equipment and calibration      devices.<\/li>\n <li>Dismantle      and reassemble heavy equipment using hoists and hand tools.<\/li>\n <li>Clean,      lubricate, and perform other routine maintenance work on equipment and      vehicles.<\/li>\n <li>Examine      parts for damage or excessive wear using micrometers and gauges.<\/li>\n <li>Schedule      maintenance for industrial machines and equipment and keep equipment      service records.<\/li>\n <li>Read      and understand operating manuals, blueprints, and technical drawings.<\/li>\n <li>Weld      or solder broken parts and structural members using electric or gas      welders and soldering tools.<\/li>\n <li>Fabricate      needed parts or items as required.<\/li>\n <li>Exhibit      a strong work ethic with the drive and desire to learn and perform tasks      efficiently. <\/li>\n <li>Maintain      effective and collaborative workplace relationships, treating others with      dignity and respect.<\/li>\n<\/ul>\n<p>Qualifications<\/p>\n<ul>\n <li>Must      pass a pre-employment physical, drug (including the use of marijuana) and      alcohol screening, Motor Vehicle Report (MVR), and additional background      screening as required by regulation and\/or industry practice. <\/li>\n <li>Must      have a valid driver's license. <\/li>\n <li>Must      be willing to travel and work in remote locations, outside, and in all      weather conditions (heat and cold)<\/li>\n <li>Experience      repairing and maintaining mechanical equipment.<\/li>\n <li>Experience      running, maneuvering, navigating, or driving vehicles or mechanized      equipment, such as forklifts, passenger and heavy equipment, and vehicles.<\/li>\n <li>Experience      analyzing information and evaluating results to choose the best solution      and solve problems.<\/li>\n <li>Experience      inspecting equipment, structures, or materials to identify the cause of      errors or other problems or defects.<\/li>\n <li>Ability      to understand and carry out general instructions in standard situations.<\/li>\n <li>Ability      to make decisions with a general understanding of procedures and company      policies to achieve set results and deadlines.<\/li>\n <li>Ability      to multi-task and work under aggressive deadline pressure.<\/li>\n <li>Ability      to maintain a positive outlook when challenged with difficult or unknown      problems.<\/li>\n <li>Possess      good time management skills.<\/li>\n<\/ul>\n<p>Typical Pay Schedule (Based upon experience)<\/p>\n<p>Mechanic I - $25\/hr.<\/p>\n<ul>\n <li>One      (1) to two (2) years\u2019 experience as a hydraulic and electrical mechanic. <\/li>\n <li>New      graduates will be considered if trained on heavy equipment with      hydraulics. <\/li>\n<\/ul>\n<p>Mechanic II - $30-$40\/hr.<\/p>\n<ul>\n <li>Three (3) to five (5) years\u2019 experience as a      hydraulic and electrical mechanic.<\/li>\n<\/ul>\n<p>Mechanic III - $40-$55\/hr. (Pay determination based on shop position or field position)<\/p>\n<ul>\n <li>Six      (6) years\u2019 experience as a hydraulic and electrical mechanic. <\/li>\n <li>Experienced      drilling support equipment, such as mud systems, generators, and      compressors preferred.<\/li>\n <li>Ability      to work independently in the field without the daily support from the      Maintenance Supervisor.<\/li>\n<\/ul>\n<p>Mechanic IV - $40-65\/hr. (Pay determination based on shop position or field position)<\/p>\n<ul>\n <li>Six      (6) plus years\u2019 experience as a hydraulic and electrical mechanic or      strong knowledge with the ability to complete all aspects of the field      mechanic position without support from the Maintenance Supervisor. <\/li>\n <li>Experienced      drilling support equipment, such as mud systems, generators, and      compressors preferred.<\/li>\n<\/ul>","%category%":"","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/dc2c4e8acbff-field-service-mechanic","%breezy_id%":"dc2c4e8acbff","%breezy_friendly_id%":"dc2c4e8acbff-field-service-mechanic","%breezy_created_date%":"2024-09-16T18:59:19.280Z","%breezy_updated_date%":"2025-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.4482948","%_wpgmp_metabox_longitude%":"-112.0725488","%rank_math_internal_links_processed%":"1"}},"id":1735,"infowindow_disable":false},{"source":"post","title":"Field Service Technician &#8211; Mining","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Field Service Technician &#8211; Mining\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Turner Staffing Group &#8211; Heavy Equipment Mechanic Turner Staffing Group is committed to changing the way mining companies do business.&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/field-service-technician-mining-2\/\" name=\"Field Service Technician &#8211; Mining\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Turner Staffing Group &#8211; Heavy Equipment Mechanic Turner Staffing Group is committed to changing the way mining companies do business.&hellip;","address":"Phoenix, AZ, USA","location":{"lat":"33.4482948","city":"Phoenix","state":"AZ","country":"United States","lng":"-112.0725488","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/field-service-technician-mining-2\/","zoom":19,"extra_fields":{"post_excerpt":"Turner Staffing Group &#8211; Heavy Equipment Mechanic Turner Staffing Group is committed to changing the way mining companies do business.&hellip;","post_content":"<p><strong><u>Turner Staffing Group - Heavy Equipment Mechanic<\/u><\/strong><br><\/p>\n<p style=\"color:#000000\"><span style=\"color:#333333\">Turner Staffing Group is committed to changing the way mining companies do business. We develop our people. We partner with our clients. We believe in win, win, win.<\/span><\/p>\n<p>We are looking for a dynamic and talented professional to fill a Heavy Equipment Mechanic role at our fast-growing, forward thinking mining services company.&nbsp;This is an opportunity to work as part of the operations team in a safe, productive, and fun environment.<span style=\"color:#333333\"><\/span><\/p>\n\n\n\n\n\n\n<p><strong>Position Description<\/strong><\/p>\n<p>The&nbsp;Mechanic is a full-time, hourly status classification.&nbsp; This position diagnoses, adjusts, repairs, fabricates, and\/or overhauls mobile mechanical, hydraulic, and pneumatic parts, equipment\/vehicles. Prefer candidates with excellent welding and fabricating experience. Travel is required.<span style=\"color:#333333\"><\/span><\/p>\n\n<p><strong>Essential Skills &amp; Knowledge<\/strong><\/p>\n<ul><li>Repair and replace damaged or worn parts<\/li><li>Operate and inspect machines or heavy equipment in order to diagnose defects<\/li><li>Diagnose faults or malfunctions to determine required repairs, using engine diagnostic equipment such as computerized test equipment and calibration devices<\/li><li>Dismantle and reassemble heavy equipment using hoists and hand tools<\/li><li>Clean, lubricate, and perform other routine maintenance work on equipment and vehicles<\/li><li>Examine parts for damage or excessive wear using micrometers and gauges<\/li><li>Schedule maintenance for industrial machines and equipment and keep equipment service records<\/li><li>Read and understand operating manuals, blueprints, and technical drawings<\/li><li>Weld or solder broken parts and structural members using electric or gas welders and soldering tools<\/li><li>Fabricate needed parts or items as required<\/li><li>Performs other related duties as required and assigned<\/li><\/ul>\n\n<p><strong>Benefits<\/strong><\/p>\n<p style=\"color:#000000\"><span style=\"color:#333333\">Turner Staffing Group&nbsp;offers a competitive salary, an excellent work culture, career advancement opportunities. Our team offers a benefits program which includes Medical, Dental, Vision, Life, and a 401k with company match. We believe in a work life balance and established paid time off for major holidays.<\/span><span style=\"color:#333333\"><\/span><\/p>\n\n<p>At Turner Staffing Group, we encourage and celebrate an inclusive environment for all employees and are proud to be an equal opportunity workplace and affirmative action employer.<\/p>","post_title":"Field Service Technician &#8211; Mining","post_link":"https:\/\/turnerstaffing.com\/position\/field-service-technician-mining-2\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"Associate","%location_country%":"United States","%location_city%":"Phoenix","%location_state_id%":"AZ","%location_state_name%":"Arizona","%location_city_state%":"Phoenix, AZ","%education%":"Unspecified","%department%":"Operations","%description%":"<p><strong><u>Turner Staffing Group - Heavy Equipment Mechanic<\/u><\/strong><br><\/p>\n<p style=\"color:#000000;\"><span style=\"color:#333333;\">Turner Staffing Group is committed to changing the way mining companies do business. We develop our people. We partner with our clients. We believe in win, win, win.<\/span><\/p>\n<p>We are looking for a dynamic and talented professional to fill a Heavy Equipment Mechanic role at our fast-growing, forward thinking mining services company.&nbsp;This is an opportunity to work as part of the operations team in a safe, productive, and fun environment.<span style=\"color:#333333;\"><\/span><\/p>\n\n\n\n\n\n\n<p><strong>Position Description<\/strong><\/p>\n<p>The&nbsp;Mechanic is a full-time, hourly status classification.&nbsp; This position diagnoses, adjusts, repairs, fabricates, and\/or overhauls mobile mechanical, hydraulic, and pneumatic parts, equipment\/vehicles. Prefer candidates with excellent welding and fabricating experience. Travel is required.<span style=\"color:#333333;\"><\/span><\/p>\n\n<p><strong>Essential Skills &amp; Knowledge<\/strong><\/p>\n<ul><li>Repair and replace damaged or worn parts<\/li><li>Operate and inspect machines or heavy equipment in order to diagnose defects<\/li><li>Diagnose faults or malfunctions to determine required repairs, using engine diagnostic equipment such as computerized test equipment and calibration devices<\/li><li>Dismantle and reassemble heavy equipment using hoists and hand tools<\/li><li>Clean, lubricate, and perform other routine maintenance work on equipment and vehicles<\/li><li>Examine parts for damage or excessive wear using micrometers and gauges<\/li><li>Schedule maintenance for industrial machines and equipment and keep equipment service records<\/li><li>Read and understand operating manuals, blueprints, and technical drawings<\/li><li>Weld or solder broken parts and structural members using electric or gas welders and soldering tools<\/li><li>Fabricate needed parts or items as required<\/li><li>Performs other related duties as required and assigned<\/li><\/ul>\n\n<p><strong>Benefits<\/strong><\/p>\n<p style=\"color:#000000;\"><span style=\"color:#333333;\">Turner Staffing Group&nbsp;offers a competitive salary, an excellent work culture, career advancement opportunities. Our team offers a benefits program which includes Medical, Dental, Vision, Life, and a 401k with company match. We believe in a work life balance and established paid time off for major holidays.<\/span><span style=\"color:#333333;\"><\/span><\/p>\n\n<p>At Turner Staffing Group, we encourage and celebrate an inclusive environment for all employees and are proud to be an equal opportunity workplace and affirmative action employer.<\/p>","%category%":"Operations","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/066af176e0a7-field-service-technician-mining","%breezy_id%":"066af176e0a7","%breezy_friendly_id%":"066af176e0a7-field-service-technician-mining","%breezy_created_date%":"2024-08-27T16:00:18.711Z","%breezy_updated_date%":"2025-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.4482948","%_wpgmp_metabox_longitude%":"-112.0725488","%rank_math_internal_links_processed%":"1"}},"id":1698,"infowindow_disable":false},{"source":"post","title":"Field Service Technician &#8211; Mining","infowindow_content":"<div class=\"tsg-jb-popup-wrapper\">\r\n  <h2 class=\"tsg-jb-popup-title\">\r\n    Field Service Technician &#8211; Mining\r\n  <\/h2>\r\n  <p class=\"tsg-jb-popup-excerpt\">\r\n    Turner Staffing Group &#8211; Heavy Equipment Mechanic Turner Staffing Group is committed to changing the way mining companies do business.&hellip;\r\n  <\/p>\r\n  <a href=\"https:\/\/turnerstaffing.com\/position\/field-service-technician-mining\/\" name=\"Field Service Technician &#8211; Mining\" class=\"tsg-jb-link\"><button class=\"button\">View<\/button><\/a>\r\n<\/div>","content":"Turner Staffing Group &#8211; Heavy Equipment Mechanic Turner Staffing Group is committed to changing the way mining companies do business.&hellip;","address":"Elko, NV, USA","location":{"lat":"40.8436459","city":"Elko","state":"NV","country":"United States","lng":"-115.7526187","onclick_action":"marker","redirect_permalink":"https:\/\/turnerstaffing.com\/position\/field-service-technician-mining\/","zoom":19,"extra_fields":{"post_excerpt":"Turner Staffing Group &#8211; Heavy Equipment Mechanic Turner Staffing Group is committed to changing the way mining companies do business.&hellip;","post_content":"<p><strong><u>Turner Staffing Group - Heavy Equipment Mechanic<\/u><\/strong><br><\/p>\n<p style=\"color:#000000\"><span style=\"color:#333333\">Turner Staffing Group is committed to changing the way mining companies do business. We develop our people. We partner with our clients. We believe in win, win, win.<\/span><\/p>\n<p>We are looking for a dynamic and talented professional to fill a Heavy Equipment Mechanic role at our fast-growing, forward thinking mining services company.<\/p>\n<p style=\"color:#000000\"><span style=\"color:#333333\">Turner Staffing Group is seeking an energetic professional who can leverage their Heavy Equipment knowledge to expand upon our fast-growing business, creating best practices for systems and scalable business processes to ensure profitable operations. <\/span><\/p>\n<p><\/p>\n<p>This person will function as a Heavy Equipment Mechanic, willingness to do, learn, perform and improve any maintenance task. <\/p>\n<p><\/p>\n<p>Tasks will be defined and evolve in all areas of mining operations to ensure preventative maintenance is practiced, repairs, equipment runs in the area of responsibility. You will report to and work with the Project Superintendent to develop heavy equipment procedures that will ensure safe operations. <\/p>\n<p><\/p>\n<p>This is an opportunity to work as part of the operations team in a safe, productive, and fun environment.<\/p>\n<p style=\"color:#000000\"><span style=\"color:#333333\"> <\/span><\/p>\n<p><strong>Position Description<\/strong><\/p>\n<p>The Mechanic is a full-time, hourly status classification.&nbsp; This position diagnoses, adjusts, repairs, fabricates, and\/or overhauls mobile mechanical, hydraulic, and pneumatic parts, equipment\/vehicles. Prefer candidates with excellent welding and fabricating experience. Travel is required.<strong><br><\/strong><br><\/p>\n<p style=\"color:#000000\"><span style=\"color:#333333\"> <\/span><\/p>\n<p><strong>Essential Skills &amp; Knowledge<\/strong><\/p>\n<ul><li>Repair and replace damaged or worn parts<\/li><li>Operate and inspect machines or heavy equipment in order to diagnose defects<\/li><li>Diagnose faults or malfunctions to determine required repairs, using engine diagnostic equipment such as computerized test equipment and calibration devices<\/li><li>Dismantle and reassemble heavy equipment using hoists and hand tools<\/li><li>Clean, lubricate, and perform other routine maintenance work on equipment and vehicles<\/li><li>Examine parts for damage or excessive wear using micrometers and gauges<\/li><li>Schedule maintenance for industrial machines and equipment and keep equipment service records<\/li><li>Read and understand operating manuals, blueprints, and technical drawings<\/li><li>Weld or solder broken parts and structural members using electric or gas welders and soldering tools<\/li><li>Fabricate needed parts or items as required<\/li><li>Performs other related duties as required and assigned<\/li><\/ul>\n<p style=\"color:#000000\"><br><\/p>\n<p style=\"color:#000000\"><span style=\"color:#333333\"> <\/span><\/p>\n<p><strong>Benefits<\/strong><\/p>\n<p style=\"color:#000000\"><span style=\"color:#333333\">Turner Staffing Group&nbsp;offers a competitive salary, an excellent work culture, career advancement opportunities. Our team offers a benefits program which includes Medical, Dental, Vision, Life, and a 401k with company match. We believe in a work life balance and established paid time off for major holidays.<\/span><\/p>\n<p style=\"color:#000000\"><span style=\"color:#333333\"> <\/span><\/p>\n<p>At Turner Staffing Group, we encourage and celebrate an inclusive environment for all employees and are proud to be an equal opportunity workplace and affirmative action employer.<\/p>","post_title":"Field Service Technician &#8211; Mining","post_link":"https:\/\/turnerstaffing.com\/position\/field-service-technician-mining\/","post_featured_image":"","post_categories":"","post_tags":"","%type%":"Full-Time","%experience%":"","%location_country%":"United States","%location_city%":"Elko","%location_state_id%":"NV","%location_state_name%":"Nevada","%location_city_state%":"Elko, NV","%education%":"","%department%":"Equipment","%description%":"<p><strong><u>Turner Staffing Group - Heavy Equipment Mechanic<\/u><\/strong><br><\/p>\n<p style=\"color:#000000;\"><span style=\"color:#333333;\">Turner Staffing Group is committed to changing the way mining companies do business. We develop our people. We partner with our clients. We believe in win, win, win.<\/span><\/p>\n<p>We are looking for a dynamic and talented professional to fill a Heavy Equipment Mechanic role at our fast-growing, forward thinking mining services company.<\/p>\n<p style=\"color:#000000;\"><span style=\"color:#333333;\">Turner Staffing Group is seeking an energetic professional who can leverage their Heavy Equipment knowledge to expand upon our fast-growing business, creating best practices for systems and scalable business processes to ensure profitable operations. <\/span><\/p>\n<p><\/p>\n<p>This person will function as a Heavy Equipment Mechanic, willingness to do, learn, perform and improve any maintenance task. <\/p>\n<p><\/p>\n<p>Tasks will be defined and evolve in all areas of mining operations to ensure preventative maintenance is practiced, repairs, equipment runs in the area of responsibility. You will report to and work with the Project Superintendent to develop heavy equipment procedures that will ensure safe operations. <\/p>\n<p><\/p>\n<p>This is an opportunity to work as part of the operations team in a safe, productive, and fun environment.<\/p>\n<p style=\"color:#000000;\"><span style=\"color:#333333;\"> <\/span><\/p>\n<p><strong>Position Description<\/strong><\/p>\n<p>The Mechanic is a full-time, hourly status classification.&nbsp; This position diagnoses, adjusts, repairs, fabricates, and\/or overhauls mobile mechanical, hydraulic, and pneumatic parts, equipment\/vehicles. Prefer candidates with excellent welding and fabricating experience. Travel is required.<strong><br><\/strong><br><\/p>\n<p style=\"color:#000000;\"><span style=\"color:#333333;\"> <\/span><\/p>\n<p><strong>Essential Skills &amp; Knowledge<\/strong><\/p>\n<ul><li>Repair and replace damaged or worn parts<\/li><li>Operate and inspect machines or heavy equipment in order to diagnose defects<\/li><li>Diagnose faults or malfunctions to determine required repairs, using engine diagnostic equipment such as computerized test equipment and calibration devices<\/li><li>Dismantle and reassemble heavy equipment using hoists and hand tools<\/li><li>Clean, lubricate, and perform other routine maintenance work on equipment and vehicles<\/li><li>Examine parts for damage or excessive wear using micrometers and gauges<\/li><li>Schedule maintenance for industrial machines and equipment and keep equipment service records<\/li><li>Read and understand operating manuals, blueprints, and technical drawings<\/li><li>Weld or solder broken parts and structural members using electric or gas welders and soldering tools<\/li><li>Fabricate needed parts or items as required<\/li><li>Performs other related duties as required and assigned<\/li><\/ul>\n<p style=\"color:#000000;\"><br><\/p>\n<p style=\"color:#000000;\"><span style=\"color:#333333;\"> <\/span><\/p>\n<p><strong>Benefits<\/strong><\/p>\n<p style=\"color:#000000;\"><span style=\"color:#333333;\">Turner Staffing Group&nbsp;offers a competitive salary, an excellent work culture, career advancement opportunities. Our team offers a benefits program which includes Medical, Dental, Vision, Life, and a 401k with company match. We believe in a work life balance and established paid time off for major holidays.<\/span><\/p>\n<p style=\"color:#000000;\"><span style=\"color:#333333;\"> <\/span><\/p>\n<p>At Turner Staffing Group, we encourage and celebrate an inclusive environment for all employees and are proud to be an equal opportunity workplace and affirmative action employer.<\/p>","%category%":"Other","%application_url%":"https:\/\/turnerstaffing.breezy.hr\/p\/f3dfde960edc-field-service-technician-mining","%breezy_id%":"f3dfde960edc","%breezy_friendly_id%":"f3dfde960edc-field-service-technician-mining","%breezy_created_date%":"2023-04-20T16:57:18.967Z","%breezy_updated_date%":"2025-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.9313066","city":"Eureka Area","state":"NV","country":"United States","lng":"-116.2304616","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.9313066","%_wpgmp_metabox_longitude%":"-116.2304616","%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.9313066","city":"Eureka Area","state":"NV","country":"United States","lng":"-116.2304616","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.9313066","%_wpgmp_metabox_longitude%":"-116.2304616","%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\"]"}}