Bumpy is currently the fastest-growing dating app in the market, with over 30,000,000+ installs in just a few years. We are scaling even faster, and you have the chance to be part of this exciting journey.
Historically, international online dating has been plagued by hookup culture, language and cultural barriers, bots, and scams. Our mission is to change that. Regardless of skin color, language, or location, we aim to help people find their international soulmate easily and safely.
Behind every swipe is a matching engine that must rank and filter across a corpus of 100M+ users in real time. We’re building a dedicated high-performance C++ service to own this, and we’re looking for an engineer who lives and breathes low-level optimization to build it.
What will you do:
Design and build a standalone high-performance matching service in C++ from the ground up;
Hold 100M+ user records in memory and run scored scans over them with sub-second latency;
Squeeze the hardware — SIMD, cache-friendly data layouts, lock-free structures, memory-mapped data;
Design the algorithms behind filtering, ranking, and exclusion (seen/liked sets) at scale;
Integrate tightly with PostgreSQL — feed the engine from the database and keep projections fresh;
Profile relentlessly and optimize hot paths down to the instruction level;
Keep latency, throughput, and error rates under tight control in production;
Coordinate with Backend/DevOps teams on data flow and deployment.
Who are you:
Performance-obsessed engineer who thinks in cache lines, branches, and cycles;
Strong algorithmic problem-solver who reaches for the right data structure, not the familiar one;
Backs every optimization with profiling and measurement, never assumptions;
Analytical mindset with the discipline to keep complex low-level code correct and maintainable.
Knowledge we need:
Modern C++ (17/20) — deep, practical, production-grade;
Strong algorithms & data structures — complexity analysis, choosing structures for the access pattern;
SIMD — SSE/AVX intrinsics, vectorization, data-oriented design (struct-of-arrays);
Low-level performance engineering — cache locality, memory alignment, branch prediction, false sharing;
Multithreading & concurrency — lock-free/wait-free structures, atomics, memory ordering;
Profiling & optimization — perf, VTune, cachegrind, flame graphs; reading assembly when needed;
PostgreSQL — solid working knowledge: query patterns, indexes, EXPLAIN ANALYZE, efficient bulk reads;
Memory management — custom allocators, arena/pool allocation, memory-mapped files, minimizing footprint.
Optional:
Building in-memory databases, search/ranking engines, or query executors;
GPU compute (CUDA) or other accelerators for scoring;
NUMA-aware programming and huge pages;
PostgreSQL internals or extension development (C API, background workers);
Capacity planning — sizing RAM, throughput, and scan cost from first principles;
Experience with build systems (CMake), sanitizers (ASan/TSan/UBSan), and CI/CD.
We offer:
One of the key technical roles in the company;
Own a performance-critical service from first line to production under real load;
Real opportunity to ship a competitive product to the global market;
Remote work;
Flexible working schedule;
Startup spirit;
Own the engine end-to-end — design, build, optimize, operate;
You’ll work close with CTO.
We also require experience in developing products from the very beginning and through supporting your code in production with real customers.
Let’s Bump!
