Product Owner â Card Content Development Transformation
Hackajob
<b>JOB DESCRIPTION</b><br><p>We are seeking a visionary and hands-on Product Owner to lead the design, build, and optimization of our digital asset management (DAM) system and reusable content library, enabling automated content creation and assembly for all card marketing initiatives. This role is central to transforming our creative development and deployment process, leveraging the full suite of Adobe solutions—including AEM Cloud, Adobe Express, GenStudio, Dynamic Media, and Firefly—integrated with our proprietary Marketing workflow platform.</p><p>As a Product Owner – Card Content Development Transformation (VP) you will lead the design, implementation, and optimization of a digital asset management (DAM) system and reusable content library for card marketing. This role drives the transformation of creative development processes by leveraging Adobe solutions (AEM Cloud, Adobe Express, GenStudio, Dynamic Media, Firefly) and integrating them with proprietary marketing workflows. Responsibilities include architecting a unified content ecosystem, enabling automated content assembly, streamlining workflows, championing governance and compliance, and fostering cross-functional collaboration. The ideal candidate has deep expertise in marketing content management, experience with Adobe tools, strong strategic and analytical skills, and a proven track record of leading teams through change.</p><p><strong>Key Responsibilities:</strong></p><ul><li>Lead the end-to-end design and implementation of a scalable DAM and reusable content library, utilizing Adobe Experience Manager (AEM) Cloud as the backbone for content management, automation, and deployment. Ensure seamless integration with Adobe Express, GenStudio, Dynamic Media, Firefly, and our campaign setup platform to support automated omnichannel content creation, personalization, and compliance.</li><li>Develop and optimize processes for automated content creation and assembly, including editorial copy, images, disclosures, and other creative assets. Champion the use of reusable, brand-agnostic components and design tokens to drive consistency, flexibility, and speed to market across our paid and owned media channels.</li><li>Collaborate with technology, marketing, and design teams to integrate Adobe solutions with our campaign setup platform, ensuring a single source of truth for content, real-time updates, and streamlined compliance review and approvals. Establish API-driven content supply chains and automated workflows to reduce manual effort and eliminate redundancies.</li><li>Define and communicate a clear product vision for the creative development suite, aligning with business objectives and marketing goals. Advocate for scalable, future-proof solutions that empower marketing teams to build, style, and manage content independently, minimizing reliance on developers and operational teams.</li><li>Serve as the day-to-day leader and facilitator, bringing together stakeholders across Card Marketing, Planning, Campaign Management, Activation, Product, Legal/Regulatory Review, and Lines of Business. Foster a collaborative environment where all voices are heard and ideas are openly debated.</li><li>Establish robust governance models and documentation to ensure accessibility, brand consistency, security, and regulatory compliance. Partner with program managers to monitor progress, resolve issues, and communicate status to executive sponsors.</li><li>Set clear problem statements, opportunity goals, baseline data, and success metrics. Maintain an analytical mindset to synthesize requirements, risks, and cross-dependencies across multiple workstreams.</li></ul><p><strong>Required qualifications, capabilities, and skills:</strong></p><ul><li>4-8+ years of related experience (product owner preferred; marketing or program management helpful)</li><li>Deep expertise in the creative development lifecycle within a marketing organization, including content creation, design, review, approval, and deployment</li><li>Proven experience architecting and delivering DAM and content management solutions, preferably using Adobe Experience Manager (AEM Cloud) and related Adobe tools</li><li>Familiarity with automated content assembly, reusable component libraries, and design token systems</li><li>End-to-end program delivery experience, including best practices, tools, and processes</li><li>Strategic thinker with strong analytical abilities and initiative to drive successful execution</li><li>Experience with agile practices and collaboration tools (e.g., Confluence, Jira, Figma, Lucid, Microsoft Teams)</li><li>Familiarity with Adobe Express, GenStudio, Dynamic Media, Firefly, and integration with workflow solutions (preferred)</li><li>Ability to operate within a highly matrixed organization, influencing and communicating effectively across all levels</li><li>Track record of leading teams through change, challenging the status quo, and delivering consistent marketing/customer experiences</li></ul><p><strong>Applicants must be authorized to work for any employer in the US. We are not able to provide immigration sponsorship or take over sponsorship of an employment visa at this time. Final job grade level and corporate title will be determined at time of offer and may differ from this posting.</strong> </p> <b>ABOUT US</b><br><p>Chase is a leading financial services firm, helping nearly half of America’s households and small businesses achieve their financial goals through a broad range of financial products. Our mission is to create engaged, lifelong relationships and put our customers at the heart of everything we do. We also help small businesses, nonprofits and cities grow, delivering solutions to solve all their financial needs. </p><p>We offer a competitive total rewards package including base salary determined based on the role, experience, skill set and location. Those in eligible roles may receive commission-based pay and/or discretionary incentive compensation, paid in the form of cash and/or forfeitable equity, awarded in recognition of individual achievements and contributions.  We also offer a range of benefits and programs to meet employee needs, based on eligibility. These benefits include comprehensive health care coverage, on-site health and wellness centers, a retirement savings plan, backup childcare, tuition reimbursement, mental health support, financial coaching and more. Additional details about total compensation and benefits will be provided during the hiring process. </p><p>We recognize that our people are our strength and the diverse talents they bring to our global workforce are directly linked to our success. We are an equal opportunity employer and place a high value on diversity and inclusion at our company. We do not discriminate on the basis of any protected attribute, including race, religion, color, national origin, gender, sexual orientation, gender identity, gender expression, age, marital or veteran status, pregnancy or disability, or any other basis protected under applicable law. We also make reasonable accommodations for applicants’ and employees’ religious practices and beliefs, as well as mental health or physical disability needs. Visit our FAQs for more information about requesting an accommodation.</p><p>Equal Opportunity Employer/Disability/Veterans</p> <br><b>ABOUT THE TEAM</b><br><p>Our Consumer &amp; Community Banking division serves our Chase customers through a range of financial services, including personal banking, credit cards, mortgages, auto financing, investment advice, small business loans and payment processing. We’re proud to lead the U.S. in credit card sales and deposit growth and have the most-used digital solutions – all while ranking first in customer satisfaction.</p> <br><p>We offer a broad array of credit cards to meet the needs of individuals and small businesses, including Chase-branded and co-branded cards in partnership with well-known companies and organizations. Merchant Services is a leading provider of payment, fraud and data security for companies, capable of authorizing transactions across global currencies.</p>