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

Make your mark at Comcast -- a Fortune 30 global media and technology company. From the connectivity and platforms we provide, to the content and experiences we create, we reach hundreds of millions of customers, viewers, and guests worldwide. Become part of our award-winning technology team that turns big ideas into cutting-edge products, platforms, and solutions that our customers love. We create space to innovate, and we recognize, reward, and invest in your ideas, while ensuring you can proudly bring your authentic self to the workplace. Join us. You’ll do the best work of your career right here at Comcast. (In most cases, Comcast prefers to have employees on-site collaborating unless the team has been designated as virtual due to the nature of their work. If a position is listed with both office locations and virtual offerings, Comcast may be willing to consider candidates who live greater than 100 miles from the office for the remote option.)<br><p><b>Job Summary</b></p>ABOUT DATABEE
You will be an innovator within DataBee. (https://www.comcasttechnologysolutions.com/databee-suite) This division specializes in offering Software-as-a-Service (SaaS) and subscription-based security solutions to large enterprises and the federal government. For the first time ever, customers are now able to purchase some of the best of Comcast’s own in-house security technologies. 

These solutions are proven-at-scale to defend critical infrastructure and effectively reduce cost. The Cybersecurity Suite efficiently improves security and compliance while keeping costs in check. 

DataBee helps enterprises transform complex security and compliance data into actionable insights.  Our compliance, risk, and security data fabric connects and normalizes data across cloud, endpoint, identity, network sources, and more to power continuous control monitoring, exposure management, security threat detection, and AI-driven analytics.  

To know more about DataBee, visit our website: https://www.databee.ai<p><b>Job Description</b></p><p>We are seeking a Senior Product Manager to own a core set of security insights and governance capabilities within the platform. </p><p>Security teams operate under constant pressure from compliance mandates, audits, and business leaders.  Yet the hardest part of staying compliant isn’t implementing the controls, it’s knowing whether those controls are effective.  Security, operations and compliance data is fragmented across tools, reporting is manual and fragile, and leaders are left questioning whether the results they see are accurate, complete, and up to date. </p><p>In this role, you will own a core set of security measurement and governance capabilities within the platform, defining how security controls are measured, how those measures are represented and governed, and how gaps are prioritized and operationalized through reporting, workflows, and remediation.  Your work turns fragmented data into trusted insights that security leaders and compliance teams rely on to make decisions every day. </p><p>You will be accountable for delivering capabilities that support cybersecurity continuous controls monitoring (CCM), while laying the foundation for broader security governance and future exposure management use cases.  You will work directly with customers and go-to-market teams to demonstrate value, support customer acquisition, and drive daily adoption.  The capabilities you build also feed AI-driven insights and workflows, enabling intelligent insights and remediation across the product.    </p><p><b>Core Responsibilities </b></p><ul><li>End-to-end ownership of security insights and governance capabilities within the platform including: </li><li>Definition and representation of security measures (what is measured, how, and why) </li><li>Continuous evaluation of security control effectiveness across domains and frameworks </li><li>A reporting and insights building experience (metrics, widgets, reusable components) used by customers to intuitively build reports to easily understand gaps and communicate control effectiveness  </li><li>Expansion of compliance framework mappings (NIST, CIS, PCI, etc), including driving which frameworks to support and how controls map to real security measures </li><li>Workflows that allow teams to select a control, understand how it is measured, and review supporting evidence </li><li>Point-in-time snapshots and internal-based views to supporting executive reporting and audits with historical comparisons </li><li>Data lineage, change detection, and dependency awareness to explain how and why control status changes over time </li><li>Remediation workflows and automation that close the loop between measured gaps and resolution </li><li>Defining what makes control effectiveness trustworthy for reporting and AI including: <ul><li>Data accuracy, completeness, and freshness </li><li>Clear, explainable logic behind results </li><li>Outputs that are defensible under scrutiny </li></ul></li><li>Defining and building the gold-standard security data sets that ensure accuracy and consistency, and reuse across: <ul><li>Reporting insights </li><li>Workflows </li><li>AI insights </li></ul></li><li>Ensuring measures, reporting, and workflows are AI-ready, feeding AI-driven insight generation and remediation recommendations </li><li>Partnering with engineering in a continuous-delivery environment to ship enterprise-ready capabilities </li><li>Working with GTM teams to ensure capabilities are clear, outcome-driven, and demo ready </li><li>Engaging directly with customers and prospects to support deal cycles and net-new customer acquisition </li><li>Occasional travel to customer sites and team events, typically less than 25%. </li><li>Collaborate with global teams and adjust working hours as needed to accommodate international time zones. </li></ul><p><b>What Success Looks Like in the First 6-12 Months</b></p><ul><li>Deliver a measurement-driven reporting and insights-building experience used daily by core personas</li><li>Expand and operationalize additional security and compliance frameworks based on customer and market needs</li><li>Launch workflows that improve control transparency, traceability, and audit readiness</li><li>Introduce point in time snapshots that support audits and executive reporting</li><li>Establish data lineage and change-detection capabilities that significantly increase trust in control effectiveness</li><li>Integrate key governance and remediation workflows with our AI insights engine</li><li>Drive measurable adoption and contribute directly to net-new customer acquisition</li></ul><p><b>Desired Skills and Experience: </b></p><ul><li>5-8+ years of product management experience in B2B SaaS </li><li>Experience in building insight-driven, measurement-heavy, or governance-focused platforms including cybersecurity, compliance, AI, or GRC products </li><li>Strong understanding for how metrics are defined, represented, and consumed for decision-making </li><li>Proven ability to translate security or governance problems into clear product capabilities </li><li>Comfort owning high-visibility product areas used by security leaders and teams </li><li>Experience working with complex, imperfect enterprise data from hundreds of enterprise security tools </li><li>Willingness and ability to engage directly with customer acquisition and expansion efforts </li></ul><p><b>Skills: </b></p><ul><li>Product experience in building security, CCM, GRC, or exposure-management platforms </li><li>Compliance framework modeling and control mapping </li><li>Reporting and insight-building design </li><li>Risk-based prioritization and gap management </li><li>AI product fluency, designing data outputs that AI can reason over </li><li>ITSM-driven remediation workflows and automation design </li><li>Delivering security and governance insights backed by trusted data with attributes such as accuracy, completeness, lineage </li><li>Developing clear product requirements, trade-off decision making, and execution </li><li>Cross-functional leadership and outstanding communication </li><li>Customer-facing product storytelling and sales support </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 flawless digital options at every touchpoint, and make them promoters of our products and services. </li><li>Know your stuff - be hard-working learners, users and advocates of our exciting 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 insights. </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>Get results and growth. </li><li>Respect and promote inclusion &amp; diversity. </li><li>Do what's right for each other, our customers, investors and our communities. </li></ul><p><b>What You Can Expect: </b></p><ul><li>Get a startup experience at a large established company. </li><li>An encouraging and casual work environment with chances to showcase your skills. </li><li>A culture of innovation and continuous learning. </li><li>Training, support, and mentoring to expand and evolve your expertise. </li><li>For more insight into our culture, check out: https://jobs.comcast.com/meet-comcast/our-culture </li></ul><ul></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>Artificial Intelligence (AI); Business-To-Business (B2B) Services; Product Management; Security Compliance</p><br><p><b>Salary:</b></p><p>National Pay Range: $116,223.39 USD-$272,398.57 USD Illinois Pay Range: $123,487.35 USD - $239,710.74 USD Colorado Pay Range: $130,751.31 USD - $250,606.69 USD Hawaii Pay Range: $152,543.20 USD - $228,814.80 USD Washington DC Pay Range: $167,071.12 USD - $250,606.69 USD Maryland Pay Range: $138,015.28 USD - $250,606.69 USD Minnesota Pay Range: $130,751.31 USD - $228,814.80 USD New York Pay Range: $138,015.28 USD - $272,398.57 USD Washington Pay Range: $130,751.31 USD - $261,502.63 USD New Jersey Pay Range: $145,279.24 USD - $261,502.63 USD Vermont Pay Range: $138,015.28 USD - $217,918.86 USD Massachusetts Pay Range: $145,279.24 USD - $261,502.63 USD California Pay Range: $130,751.31 USD - $242,132.06</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>The application window is 30 days from the date job is posted, unless the number of applicants requires it to close sooner or later.<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>15 Years +</p>