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

<p><strong>Who We Are</strong></p>
<p>Babylist is the leading registry, e-commerce, and content platform for growing families. More than 9 million people shop with Babylist every year, making it the go-to destination for seamless purchasing, trusted guidance, and expert product recommendations for new parents and the people who love them. What began as a universal registry has grown into a full ecosystem for new parents, including the Babylist Shop, Babylist Health, and a flagship showroom in Los Angeles. Hundreds of brands in baby and beyond partner with Babylist to engage meaningfully with families during one of life’s most important transitions. With over $1 billion in annual GMV, and more than $500 million in 2024 revenue, Babylist is reshaping the $320 billion baby product industry. We’re helping parents feel confident, connected, and cared for at every step. As we build the generational brand in baby, our mission remains simple: to connect growing families with everything they need to thrive.To learn more, visit www.babylist.com.</p>
<p><strong>Our Ways of Working</strong></p>
<p>Babylist thrives as a remote-first company, with HQ team members located across the U.S. and Canada. We meet in person twice a year — once as a company and once by department to strengthen the relationships that power our work. We show up consistently, stay purpose-driven, leverage AI to amplify our impact, and achieve results — together, from anywhere.</p>
<p>Our Fulfillment Center team works on-site in Commercial Point, OH to bring the Babylist experience to life — and they're just as central to our mission as anyone working remotely. Different in how we work. Unified in why we do it.</p>
<p><strong>What the Role Is</strong></p>
<p>Babylist is seeking an experienced and highly accountable <strong>General Manager</strong> to lead our Columbus, Ohio fulfillment center, a critical node in our expanding network and the model for future sites. This is a fully on-site role requiring presence at the Columbus fulfillment center five to six days per week, with the ability to flex across shifts as needed. Relocation assistance is available for the right candidate who is not currently located in the Columbus, Ohio market.</p>
<p>This is a senior operational leadership role with full building accountability across safety, service, labor strategy, cost management, productivity, culture, and change execution. Our site is entering a period of meaningful volume growth, and we need a proven, hands-on operator who has successfully led high-volume distribution centers through scaling, process maturity evolution, and organizational performance transformation.</p>
<p>We are looking for someone with a genuine seek-to-understand mindset who meets the site where it is today while building the structure, rigor, and accountability required for the next stage of operational maturity. The best operators here earn trust on the floor before pushing pace — they lead by showing up, not by announcing. This is not a developmental role; we are looking for a seasoned General Manager who has delivered measurable results at scale and is ready to do it again.</p>
<p>The Columbus site will serve as the operational blueprint for future Babylist fulfillment locations — this means the incoming GM will not only run the building but will contribute to documenting scalable playbooks, partnering on network expansion decisions, and influencing how Babylist builds and operates sites going forward.</p>
<p><strong>Who You Are</strong></p>
<ul>
<li>10+ years of progressive fulfillment or distribution leadership, including 5+ years as the senior-most site leader in a high-volume facility managing 300+ associates across multiple shifts</li>
<li>Proven track record leading large-scale operations through significant volume growth (20–50%+ increases, network expansion, or building ramp-ups)</li>
<li>Full P&amp;L or site-level financial accountability, including labor budgeting, workforce planning, and cost control</li>
<li>Experience building scalable labor models, capacity plans, and productivity roadmaps in high-growth environments</li>
<li>Demonstrated ability to implement operational maturity improvements across standard work, accountability systems, WMS enhancements, and lean or continuous improvement practices</li>
<li>Comfortable inheriting operations at varying levels of maturity and systematically driving both process and cultural transformation</li>
<li>Highly visible, floor-based leadership style with a seek-to-understand approach; uses structured observation and data to diagnose issues and coaches leaders in real time</li>
<li>Proven ability to elevate Operations Managers and frontline leaders through clear accountability standards, performance expectations, and active development</li>
<li>Deep knowledge of WMS platforms, labor management systems, and KPI dashboards; technically fluent and able to identify, pilot, and scale system and AI-driven enhancements</li>
<li>Experience with engineered labor standards, productivity measurement, and strong command of safety programs, compliance, and OSHA standards</li>
<li>Direct experience leading leaders across multiple levels (Ops Managers, ASMs, Supervisors) with a track record of building bench strength and addressing performance gaps decisively</li>
<li>You're comfortable and enthusiastic about working in an AI-forward environment where AI tools are part of daily operations</li>
<li>You embrace using technology to enhance your work while keeping people at the center</li>
</ul>
<p><strong>How You Will Make An Impact</strong></p>
<ul>
<li>Own all aspects of site performance across safety, quality, service, cost, and people, delivering consistently against SLAs and customer experience standards</li>
<li>Establish operational rhythms (daily, weekly, and monthly business reviews) that drive accountability and visibility at every level of the organization</li>
<li>Develop and manage labor budgets and staffing models, optimizing headcount planning to support growth projections while maintaining financial discipline</li>
<li>Improve productivity metrics and eliminate throughput constraints through standardized processes, continuous improvement initiatives, and measurable gains in output per labor hour</li>
<li>Lead operational upgrades and process maturity improvements without disrupting service levels, serving as a stabilizing presence during periods of significant transformation</li>
<li>Guide the site through meaningful volume expansion over the next several years, implementing scalable systems and structures that position Columbus as the model for future Babylist fulfillment locations — including contributing to playbook development and network expansion planning</li>
<li>Coach and develop Operations Managers and shift leaders, building cross-shift collaboration, clear accountability standards, and a strong leadership bench</li>
<li>Create leadership development plans and succession pipelines that elevate frontline leaders and address performance gaps decisively and constructively</li>
<li>Partner cross-functionally with Supply Chain, Finance, and corporate teams to align on priorities, resource needs, and operational execution</li>
<li>Lead with humility, curiosity, and presence, building trust through follow-through and fostering a safe, inclusive, and high-performance culture</li>
</ul>
<p><strong>Physical Requirements</strong></p>
<p>While this role involves leadership and oversight responsibilities, it also requires regular physical presence and activity on the fulfillment floor. Physical expectations include:</p>
<ul>
<li>Ability to stand and walk for extended periods (up to 10–12 hours per shift) with scheduled breaks</li>
<li>Ability to walk the floor extensively, averaging 10,000+ steps per day</li>
<li>Ability to lift and move items up to 20 lbs occasionally throughout the shift</li>
<li>Comfort with pushing, pulling, bending, twisting, and performing repetitive motions as needed to support team operations</li>
</ul>
<p><strong>Why You Will Love Working At Babylist</strong></p>
<p><strong>Our Culture</strong></p>
<ul>
<li>We work with focus and intention, then step away to recharge</li>
<li>We believe in exceptional management and invest in tools and opportunities to connect with colleagues</li>
<li>We build products that positively impact millions of people's lives</li>
<li>AI is intentionally embedded in how we work, create, and scale—supporting innovation and impact</li>
</ul>
<p><strong>Growth &amp; Development</strong></p>
<ul>
<li>Competitive pay and meaningful opportunities for career advancement</li>
<li>We believe technology and data can solve hard problems</li>
<li>We're committed to career progression and performance-based advancement</li>
</ul>
<p><strong>Compensation &amp; Benefits</strong></p>
<ul>
<li>Competitive salary with equity and bonus opportunities</li>
<li>Company-paid medical, dental, and vision insurance</li>
<li>Retirement savings plan with company matching and flexible spending accounts</li>
<li>Generous paid parental leave and PTO</li>
<li>Perks for physical, mental, and emotional health, parenting, childcare, and financial planning</li>
</ul>
<p><strong>About Compensation</strong></p>
<p>We use a market-based approach to compensation. The starting salary range for this role is:</p>
<p><strong>$161,000 to $180,000</strong></p>
<p>Your starting salary will be based on your location, experience, and qualifications, with increases over time tied to performance, role growth, and internal pay equity.</p>
<h3><strong>Important Notices</strong></h3>
<p><strong>Interview Process &amp; Consent</strong><strong><br></strong>Babylist uses AI to record and transcribe all interviews for evaluation purposes in accordance with CCPA and GDPR. By participating in an interview, you consent to this recording and transcription.</p>
<p><strong>Interview Integrity</strong><strong><br></strong>During the interview process, we're evaluating your individual problem-solving skills, creativity, and approach to challenges. While AI tools like ChatGPT, Claude, and Cursor are part of your daily toolkit once you join Babylist, all interviews, assessments, and take-home assignments must be completed independently. </p>
<p>You may not use AI tools, third-party services, coaching platforms, or content-farming services during any part of the interview process unless we explicitly permit it. We will clearly communicate when AI tools are allowed for specific assessments.</p>
<p>Any indication of third-party assistance or AI-generated responses will result in immediate disqualification. We may also verify educational credentials through third-party sources—providing false or misleading information will result in removal from consideration.</p>
<p><strong>Official Communication</strong><strong><br></strong>All communication will come only from the Babylist Talent Team via an @babylist.com email address. We will never request payment, bank information, or personal financial details. Be cautious of fraudulent outreach via non-company email addresses, messaging platforms (e.g., WhatsApp, Telegram), or unsolicited phone calls. Verify legitimate opportunities on our careers page.</p>
<p><strong>Friends or Family at Babylist? </strong></p>
<p>Babylist is committed to fairness and equal opportunity at every stage of our hiring process. In line with our conflict of interest policy, applicants must disclose any family or close personal relationships with current Babylist employees. This helps ensure unbiased hiring decisions and a positive work environment.</p>
<p><strong>SMS Consent</strong><strong><br></strong>You may opt in to receive text message updates about your application or interviews. Opting out will not affect your application status—communication will continue via email or phone. Message and data rates may apply. Reply STOP to unsubscribe or HELP for assistance. See our Privacy Policy for more information.</p>