hackajob is collaborating with Comcast to connect them with exceptional professionals for this role.

<p>Comcast Advertising is driving the TV advertising industry forward, from delivering ads to linear and digital audiences to pioneering the tech that makes it possible. We help brands connect with their audiences on every screen using advanced data, technology, and premium video content.  Our media sales division helps local, regional, and national brands reach potential customers through multiscreen TV advertising. Our ad tech division FreeWheel provides comprehensive adtech that makes it easier to buy and sell premium video advertising across all screens, data types, and sales channels.</p><br><p><b>Job Summary</b></p><p>Responsible for managing complex projects through entire project lifecycle (inception, design, development, integration and test, trial and deployment). Act as a liaison with appropriate company personnel and vendors to ensure project compliance to standards, coordinate multiple complex high priority tasks. Assure feature and functionality and performance metrics requirements are defined. Initiate, facilitate and monitor specific inter/intra-departmental project progress and performance to assure quality and on time delivery. Ensure milestone dates are met. Monitor risks during various stages of the project and escalate issues to the appropriate level of management. Maintain project status reports on projects. Create and manage contingency plans for projects. Estimate and manage budgets. Evaluate impact change request against communicated timelines. Integrates knowledge of business and functional priorities. Acts as a key contributor in a complex and crucial environment. May lead teams or projects and shares expertise.</p><p><b>Job Description</b></p><p><b>Core Responsibilities</b></p><ul><li>Integrate SAFe‑informed practices into project coordination, ensuring alignment with cross‑team Agile processes and adapting to the rhythms of Release Trains, Product Management, and Engineering.</li><li>Utilize product and portfolio management tools such as Aha! for feature definition and roadmap alignment, and Jira for backlog management, dependency tracking, and reporting.</li><li>Prepare and deliver clear, concise status updates, risk summaries, and executive‑ready communications for senior leadership across Technology and Business organizations.</li><li>Influence and collaborate with executive stakeholders, articulating options, risks, and impacts to support timely decision‑making.</li><li>Manage deployment readiness when applicable, including go/no‑go criteria, cutover planning, communication, and post‑deployment validation to ensure smooth and successful releases.</li><li>Coordinate scoping and architecture review activities for initiated programs and follow process for program approval at architecture initiation board.</li><li>Create and track end to end project plan in conjunction with the lead engineer.</li><li>Track tasks and milestones across all parties, including vendors.</li><li>Coordinate, manage and drive test organization activities.</li><li>Facilitate bug triage, manage bug lists across vendors, track issue resolution with lead engineer.</li><li>Coordinate change request generation and tracking.</li><li>Make project scheduling decisions in conjunction with the lead engineer or facilitate conversations necessary for decision making.</li><li>Report on project's progress as required by product engineering management.</li><li>Identify and manage critical path and risk areas and create risk response and mitigation plans.</li><li>Report weekly (or as necessary) on any risks/issues.</li><li>Escalate issues as required to unblock open issues.</li><li>Work with other project managers to track and manage inter-project dependencies.</li><li>Communicate updates on major milestones, escalations and status to lead engineer and lead project manager.</li><li>Work with lead engineer and management to set project specific budget.</li><li>Project spend rates based on the budgets.</li><li>Manage within budgetary objectives set by manager, monitoring and controlling costs within functional area.</li><li>Mentor junior level project managers on the team.</li><li>Consistent exercise of independent judgment and discretion in matters of significance.</li><li>Regular, consistent and punctual attendance. Must be able to work nights and weekends, variable schedule(s) and overtime as necessary.</li><li>Other duties and responsibilities as assigned.</li></ul><p>Requirements:</p><ul><li>Familiarity with SAFe (Scaled Agile Framework) concepts and ceremonies; certification not required.</li><li>Hands‑on experience with Aha! and Jira for planning, tracking, and reporting across complex programs.</li><li>Strong executive presence and communication skills, with demonstrated experience engaging and influencing senior leadership.</li><li>Ability to translate technical information into clear business‑focused updates tailored for executives.</li></ul><p><b>Employees at all levels are expected to:</b></p><ul><li>Understand our Operating Principles; make them the guidelines for how you do your job.</li><li>Own the customer experience - think and act in ways that put our customers first, give them seamless digital options at every touchpoint, and make them promoters of our products and services.</li><li>Know your stuff - be enthusiastic learners, users and advocates of our game-changing technology, products and services, especially our digital tools and experiences.</li><li>Win as a team - make big things happen by working together and being open to new ideas.</li><li>Be an active part of the Net Promoter System - a way of working that brings more employee and customer feedback into the company - by joining huddles, making call backs and helping us elevate opportunities to do better for our customers.</li><li>Drive results and growth.</li><li>Support a culture of inclusion in how you work and lead.</li><li>Do what's right for each other, our customers, investors and our communities.</li></ul><p><b>Disclaimer:</b></p><ul><li>This information has been designed to indicate the general nature and level of work performed by employees in this role. It is not designed to contain or be interpreted as a comprehensive inventory of all duties, responsibilities and qualifications.</li></ul><p>Comcast is an equal opportunity workplace.  We will consider all qualified applicants for employment without regard to race, color, religion, age, sex, sexual orientation, gender identity, national origin, disability, veteran status, genetic information, or any other basis protected by applicable law.  Comcast will consider for employment applicants with arrest or conviction records in accordance with the requirements of applicable law, including the San Francisco Fair Chance Ordinance, the Los Angeles Fair Chance Initiative for Hiring Ordinance, the Los Angeles County Fair Chance Ordinance for Employers and the California Fair Chance Act. Please note that federal state, or local laws and regulations may restrict or prohibit Comcast from hiring individuals convicted of certain crimes. Additionally, an applicant’s criminal history may have a direct, adverse, and negative relationship on the job duties of this position, which may result in the withdrawal of a conditional offer of employment.</p><br><p><b>Skills:</b></p><p>Execution Excellence; Solution Oriented Approach; Business Acumen; Financial Acumen; Solution-Oriented; Adaptability; Agile Methodology</p><br><p><b>Salary:</b></p><p>National Pay Range: $85,781.96 USD-$201,051.47 USD Illinois Pay Range: $91,143.33 USD - $176,925.29 USD Colorado Pay Range: $96,504.70 USD - $184,967.35 USD Hawaii Pay Range: $112,588.82 USD - $168,883.23 USD Washington DC Pay Range: $123,311.57 USD - $184,967.35 USD Maryland Pay Range: $101,866.08 USD - $184,967.35 USD Minnesota Pay Range: $96,504.70 USD - $168,883.23 USD New York Pay Range: $101,866.08 USD - $201,051.47 USD Washington Pay Range: $96,504.70 USD - $193,009.41 USD New Jersey Pay Range: $107,227.45 USD - $193,009.41 USD Vermont Pay Range: $101,866.08 USD - $160,841.17 USD Massachusetts Pay Range: $107,227.45 USD - $193,009.41 USD California Pay Range: $96,504.70 USD - $178,712.41</p><p>Comcast intends to offer the selected candidate base pay within this range, dependent on job-related, non-discriminatory factors such as experience. The application window is 30 days from the date job is posted, unless the number of applicants requires it to close sooner or later.</p><br><p>The application window is 30 days from the date job is posted, unless the number of applicants requires it to close sooner or later.</p><br><p>Base pay is one part of the Total Rewards that Comcast provides to compensate and recognize employees for their work. Most sales positions are eligible for a Commission under the terms of an applicable plan, while most non-sales positions are eligible for a Bonus. Additionally, Comcast provides best-in-class Benefits to eligible employees. We believe that benefits should connect you to the support you need when it matters most, and should help you care for those who matter most. That?s why we provide an array of options, expert guidance and always-on tools, that are personalized to meet the needs of your reality ? to help support you physically, financially and emotionally through the big milestones and in your everyday life. Please visit the  compensation and benefits summary  on our careers site for more details.</p><br><p><b>Education</b></p><p>Bachelor's Degree</p><p>While possessing the stated degree is preferred, Comcast also may consider applicants who hold some combination of coursework and experience, or who have extensive related professional experience.</p><p><b>Relevant Work Experience</b></p><p>7-10 Years</p>