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

<p><strong>Some careers open more doors than others.</strong></p><p>If you’re looking for a career that will unlock new opportunities, join HSBC and experience the possibilities. Whether you want a career that could take you to the top, or simply take you in an exciting new direction, HSBC offers opportunities, support and rewards that will take you further.</p><p><strong>Business Descriptor:</strong></p><p><strong>Global Trade Solutions (GTS)</strong></p><p>Global Trade Solutions comprises over 4,500 people across more than 60 countries, helping suppliers and buyers with their export and import finance needs. Trade is where HSBC began in 1865, when we financed commerce between Europe, North America and Asia.</p><p>We are currently seeking an experienced professional to join the GTS India Solutions Implementation team as the Supplier Engagement Lead.</p><p><strong>Role Title:</strong> Vice President - Supplier Engagement</p><p><strong>Job Family/Sub Job Family:</strong> GTS Solutions Implementation</p><p><strong>Business:</strong> Global Trade Solutions (GTS)</p><p>Reporting to the Country Lead of Solutions Implementation, GTS, India the individual shall be responsible to manage the implementation and client onboarding function for Core and Structured trade products along with overseeing the supplier engagement activities.</p><p>The key reposnbilities include deployment of new platforms and e-Channel functionality and providing product and implementation expertise to Sales, Coverage, and other stakeholders.</p><p><strong>Principal Responsibilities:</strong></p><ul><li>Leading client discussions to drive the engagament, plans, and priorities for the delivery of the agreed client requirements, ensuring requirements and variations in the business model are accurately accounted for in our Client on-boarding journey.</li><li>Delivery of client programmes as part of end-to-end client execution and transaction fulfilment lifecycle.</li><li>Leverage Client feedback to shape client proposition and new product development activity across.</li><li>Oversee the efficient completion of technical and operational on-boarding activities for new to trade or new to bank clients.</li><li>Ensure the provision of transactional and channel support to clients, understanding their on-boarding requirements and ensuring their timely implementation within GTS.</li><li>Act as the representative for the bank interacting where appropriate with the client in pre-sale, negotiation and post-sale activities on selected high profile pitches involving complex implementation.</li><li>Develop a close relationship with customers, managing these relationship and client expectations from sales, implementation/on-boarding and go-live to business as usual and migration to Client Services ownership.</li><li>Deliver fair outcomes for our customers and ensure own conduct maintains the orderly and transparent operation of financial markets.</li><li>Support achievement of the HSBC vision, Values, goals and culture in personal behaviour, actions and decision making.</li><li>Encourage and enable constructive cross-country and cross-business teamwork by demonstrating collaboration and matrix management in action and challenging actions and behaviours that are not consistent with HSBC's diversity policy and/or the best interests of the business and its customers.</li><li>Develop and recommend changes and improvements to operating models, procedures and practices based on subject matter expertise and understanding of HSBC and market best practice.</li><li>Communicate and adhere to HSBC policy and procedures in order to ensure good operational, financial and project management, policy and procedural compliance and early identification and effective resolution or escalation of issues that arise.</li></ul><p><strong>Stakeholder Management:</strong></p><ul><li>Manage key relationships with internal and external stakeholders, developing and maintaining strong working relationships with:</li></ul><ul><li>Internal - Risk and Compliance, Relationship Management, Product and Proposition Management, Client Services, Business Risk &amp; Control Management (BRCM), Technology, and Business Development</li><li>External - key clients.</li></ul><ul><li>Develop a close relationship with customers, managing these relationship and client expectations from sales, implementation/on-boarding and go-live to business as usual and migration to Client Services ownership.</li><li>Work closely with colleagues across Business Development and Solution Structuring, providing support on deals with priority or complex clients and ensuring alignment in strategy regarding target client groups.</li><li>Strive for class-leading customer experience by cultivating a consistent selling and relationship management culture.</li><li>Maintain close liaison with India, regional colleagues / stakeholders, and global leadership to provide input into the strategic direction of GTS.</li><li>Deliver fair outcomes for our customers and ensure own conduct maintains the orderly and transparent operation of financial markets.</li></ul><p><strong>Supplier Onboarding &amp; Engagement:</strong></p><ul><li>Grow the SCF book including throughput by discussing with anchor corporates / buyers and ensure utilisations across the book is above the agreed threshold.</li><li>Partner with procurement leadership from client organisations and create the supplier engagement stragey.</li><li>Ensure suppliers understand the benefits of Supply Chain Financing (SCF) and facilitate their enrolment.</li><li>Conduct detailed working capital analysis for suppliers as needed.</li><li>Develop and execute supplier engagement strategies for assigned programs.</li><li>Represent HSBC’s SCF program at supplier conferences and events.</li><li>Provide sales and technical support throughout the supplier enrolment journey.</li></ul><ul><li>Management Graduate with a minimum of 6 years of relevant trade experience</li><li>CA/CFA/Post-Graduate in Business Administration preferred.</li><li>Banking experience of over 8 years</li><li>Current experience in line with key accountabilities</li><li>Strong understanding of Trade Products and Services being offered to clients.</li><li>Understanding of various Channels offered / available to clients.</li><li>Strong knowledge and experience on various system Integration is a distinct advantage.</li><li>Understand various industry standard file formats, conversant with connectivity setup.</li><li>Should be able to work independently on file testing and connectivity establishment.</li></ul><p>HSBC is committed to building a culture where all employees are valued, respected and opinions count. We take pride in providing a workplace that fosters continuous professional development, flexible working and opportunities to grow within an inclusive and diverse environment.</p><p>Personal data held by the Bank relating to employment applications will be used in accordance with our Privacy Statement, which is available on our website.</p><p><em>Issued by The Hongkong and Shanghai Banking Corporation Limited, India</em></p>