Analytics Engineer

About RealPlay

RealPlay is a fast-growing Tel Aviv startup in the gaming industry. At the heart of how we operate is a deep understanding of our players, and that depends on clean, trustworthy data. That's where you come in.

The Role

Raw data isn't built for thinking with. It's structured for storage: captured efficiently, indexed for retrieval, but shaped for the machine that wrote it, not the person trying to ask questions of it. Turning raw events into something a company can actually reason with takes deliberate work, and that work is what you'll be doing as an Analytics Engineer

You turn raw event logs into clean, well-defined, trustworthy data models: the canonical datasets the rest of the company reasons in. The models you build become the foundation on which everything downstream depends, so a clean foundation makes the next ten analyses faster, the next ten conclusions sharper, the next ten decisions better-grounded. Good analytics compounds on top of good models.

The operational framework is engineering discipline applied to analytical artifacts. The models you ship are versioned, reviewed, and tested like production code. Pipelines are observable, so problems surface before consumers find them. Columns are named and documented honestly, because everything downstream (analyses, dashboards, the AI agents querying your data) depends on those names meaning what they say. The deepest form of documentation, though, is the architecture itself: clean models are their own explanation.

This work has always mattered, but in an AI-native world, it becomes the most leveraged data work in the company. The ceiling on what an LLM can do with your company's data is set by how clearly that data is modeled. Tangled tables produce confident nonsense; clean, trustworthy ones produce real leverage. The architecture you build is the substrate on which every AI capability (agents, copilots, automated analyses) operates.

The role itself has shifted, too. You orchestrate LLMs more than you type line by line. They draft the SQL, the tests, the documentation; you decide what to model, whether the output is trustworthy, and whether the architecture will hold up five models from now. The judgment is yours; the typing is increasingly theirs.

In This Role, You Will

• Design canonical data models (clear grain, honest names, predictable behavior) that the whole analytics function builds on.
• Own those models end-to-end: the dbt implementation, the testing, the observability, the SLAs that make them dependable.
• Evolve the data layer as the product changes, so the architecture stays coherent rather than accumulating legacy.
  
  

• You think in first principles. Asked to model active users, you don't reach for the nearest existing query. You ask what active actually means here, who'll use the answer, and what the right grain is. You're suspicious of definitions that haven't been examined.
• You care about correctness in a way that's almost aesthetic. A column with a misleading name, a model that silently double-counts, a number that looks right but isn't: these bother you the way a typo bothers a careful writer.
• You take pleasure in things being well-built. A tangled ad-hoc pipeline, an inconsistent naming scheme, a model nobody trusts: they make you want to fix them. You notice when something is well-architected and care about being the person who builds it that way.
• You think in interfaces. Names are contracts. Grain is a promise. The model you ship today is something other people will build on for years, and you design accordingly.
• You have engineering hygiene as second nature, or a hunger to develop it. Version control, tests, code review, and observability. You see these as what separates work that compounds from work that has to be redone.
• You're curious about the business. Understanding what the analytics function is trying to figure out makes you radically better at building the data layer it actually needs.
  
  

• Engineering practices that travel with you regardless of tool: Git, code review, writing tests, and reading other people's code.
• A version-controlled, tested transformation framework (we use dbt).
• An instinct for SQL query shape and grain: the picture of right you carry before any query runs. That's what makes judging the LLM's output possible at all.
• Scripting outside the warehouse for orchestration, custom ingestion, automation (Python or similar).
• A modern cloud warehouse (we use BigQuery; the patterns transfer).
• Fluency working with AI coding tools: taste for what to delegate, how to prompt for quality, how to verify the output (Cursor, Copilot, agents). This is how the work happens, daily.