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>Global Trade Solutions</strong> ( GTS)</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><strong>Role Purpose</strong> </p><ul><li>The role holder is responsible for consultative selling, implementation and management of GTS products to customers and prospects and managing existing GTS relationships to promote increased profitability and relationship depth, while minimizing risk </li><li>They will develop new revenue streams by identifying and selling innovative GTS solutions to a portfolio of clients thus maximizing commercial profitability and relationship depth. This will include responsibility for pricing, reviewing and negotiating the full range of GTS services together with effecting any cost reduction initiatives required by the Group. </li><li>Drives best practice in lending and risk policies ensuring this remains in line with economic and market practices <strong> </strong> </li></ul><p><strong>Impact on the Business</strong>  </p><ul><li>To manage a client portfolio in order to maintain existing and generate new income for the business. Undertake sector/portfolio  planning and client monitoring/contact</li><li>Develop effective strategies for maintaining and growing a client portfolio in order to maintain and generate new income for the Group. This will involve initiatives such as sector planning and client/contact monitoring to ensure efforts and support GTS business objective</li><li>Manage portfolio customers and follow end to end CM process as defined by Business Development Transformation</li><li>To manage costs within plan, keep losses to a minimum and identify any cost reduction initiatives.</li><li> Work closely with colleagues to promote awareness of GTS products, strategies and competitor information amongst the RM and other strategic business communities.</li><li> Maintain awareness of the applicable regulatory and business environment: understand audit, tax and legal implications and changes as they affect he customers and the Bank.  </li></ul><p><strong>Customers / Stakeholders</strong>  </p><ul><li>Develop an appropriate calling plan to efficiently and effectively achieve goals and objectives. Through consultative selling, design and implement workable, innovative solutions for customers individual needs plus generate     and receive quality referrals for/from other parts of the Group.</li><li>Where appropriate undertake professional presentations etc. to customers in support of potential opportunities portraying HSBC in the best possible light against a backdrop of competition from local, regional and/or global banks.</li><li> Maintain and enhance the image of HSBC through the planning and execution of conferences, industry sector days, internal &amp; external client road shows, active participation in industry associations and other such suitable events.</li><li>Maintain close liaison with intra country, intra region and cross regional colleagues/stakeholders so as to provide input into the strategic direction of Sales, Product and Client Management functions Incremental revenue and customer satisfaction</li><li>By matching customers’ requirements in response to proposal requests (RFP’s etc.)</li><li>Provision of appropriate strategic business ideas based on awareness of market and industry initiatives and customer feedback. Sharing of best practices and to the overall direction of GTS regional and global business.</li></ul><p><strong>Leadership &amp; Teamwork</strong>  </p><ul><li>Be a team player. Work with the team members and colleagues in order to perform the role the best of abilities.</li><li>Demonstrating excellence in sales and following end to end sales process as defined internally</li><li>Be self-motivated and achieve results in the face of setbacks</li><li>Keep management informed of progress/obstacles towards sales targets</li><li>Establish an interactive dialogue process with Risk Management teams in order to build a sustainable  asset growth</li><li>By demonstrating and sharing best practices with colleagues.</li><li>Sharing of feedback to appropriate stakeholders and colleagues</li><li>By provision of commentary to team leader, senior client management, product and sales etc.</li></ul><p><strong>Operational Effectiveness &amp; Control</strong>  </p><ul><li>Ensure compliance monitoring is in place in accordance with HSBC and regulatory standards.</li><li> Ensure all CM Sales activity documentation is complete to provide performance tracking and targeting future sales efforts</li><li> Continually assess the CM Sales processes to identify improvements</li><li> Keep Team leader informed of any obstacles, issues etc.</li><li>Compliance with and management of sales suitability risks and requirements</li><li>Ensure all completed sales and prospecting activity documentation is appropriately completed, approved and stored to provide performance tracking, targeted future sales efforts and compliance with sales and transactional suitability guidelines and requirements</li><li> Monitors own completion of mandatory training</li><li> No unknown crisis issues</li><li> Liaise with Client Service Teams, CoE inclusive, to certify a deliver an outstanding services to clients </li></ul><p><strong>Major Challenges</strong> </p><ul><li>Drive sales from existing clients and manage attrition</li><li>Managing multiple time sensitive tasks</li><li>Constantly evaluate - Customer banking practices and trends in the market, GTS systems and techniques employed and the competitive market place.</li><li>Adapting to a fast pace work environment and continually changing lines of communication, technological advances etc</li><li>Ensuring RM community is sufficiently knowledgeable with GTS products/services/ regulation and having confidence they are able to continually apply this knowledge to their client base </li></ul><p><strong>Role Context</strong> </p><ul><li>GTS is a key strategic business for the HSBC Group under Corporate and Institutional Banking ( CIB) and its history is mixed with almost 150 years of Group history. HSBC is recognized worldwide as “the World's leading and largest trade bank and a Leading player in the receivables finance market” and its global leadership is unquestionable.</li><li>Through capitalizing on the Group’s international network and on the regional expertise, GTS India not only consistently holds an important status internally as a reliable and relevant income generator as well externally receiving formal market recognition.</li><li>The Group has defined International Trade as the highest priority area to explore business opportunities for next years, engaging all levels in the organization to position HSBC as the primary provider for Corporate clients for their international needs worldwide.</li><li>Must have a thorough understanding of the GTS business and takes a long term view of expected changes</li><li>To look for new sales opportunities, increase wallet share and generally ensure the performance of the client</li><li>Ensure client satisfaction including identifying and dealing with actual or potential business or relationship risks </li></ul><p><strong>Management of Risk</strong> </p><ul><li>Adheres to processes and controls to identify and mitigate risks and ensures timely escalation of control issues and reputation risks. </li><li>The jobholder will ensure the fair treatment of our customers is at the heart of everything we do, both personally and as an organisation. </li><li>The jobholder will also continually reassess the operational risks associated with the role and inherent in the business, taking account of changing economic or market conditions, legal and regulatory requirements, operating procedures and practices, management restructurings, and the impact of new technology. Additionally they will ensure they effectively manage sales suitability, money laundering, counter terrorist financing, fraud, and reputational risk. </li><li>This will be achieved by ensuring all actions take account of the likelihood of operational risk occurring. Also by addressing any areas of concern in conjunction with line management and/or the appropriate department</li></ul><p><strong>Qualifications - External</strong></p><ul><li>Minimum Bachelor’s degree / Graduation or as required for the role, whichever is higher</li><li>Extensive knowledge of global trade finance, services, products and techniques.</li><li>Extensive knowledge of the market &amp; market trends, competitive environment and regulatory environment.</li><li>Detailed knowledge of GTS back and front office area</li><li> Detailed knowledge if Credit &amp; Risk including techniques to mitigate risk</li><li>Broad knowledge of HSBC Group companies and product ranges</li><li>Sales &amp; Client Management experience at a senior level including dealing with senior executives plus a proven sales record</li><li>Proven ability in identifying and meeting customer needs through matching a broad range of  products and services</li><li>Strong credit assessment skills, particularly with regard to more complex and structured facilities with an international dimension</li><li>Proven ability to deliver creative and flexible customer solutions.</li><li>Ability to understand a customers business and the fundamentals of running a business</li><li>Good level of business acumen and commercial awareness, including economic, cultural, procedural and regulatory issues</li><li> Ability to interact with business customers at all levels</li><li>Excellent interpersonal skills and ability to interact and build relationships with internal and external stakeholders</li><li>Excellent time management, planning and organisation skills</li><li>Excellent range of communication skills, including written, verbal, and the ability to deliver compelling presentations</li><li>Strong analytical skills  </li></ul><p><strong>Desirable</strong></p><p>GTS related industry qualifications </p><p><strong>Additional Information</strong></p><ul><li><em>Mandatory to successfully complete Anti-Money Laundering and Sanctions training and post-course assessment, as required.</em></li></ul><p><em>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.</em></p><p><em>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.</em></p><p><em>Issued by The Hongkong and Shanghai Banking Corporation Limited, India </em></p>