InsulaLabs

We are looking for a Senior Data Engineer. This is not a standard ETL role. You will work on a high-load system processing 10,000+ executions per minute, building scalable pipelines where AI and LLM logic are embedded directly into production data flows.

The role combines data engineering, backend thinking, infrastructure ownership, and real production AI integration.

What you will do:

• Design and maintain scalable data pipelines in Python on Google Cloud Platform
• Build and optimize AI-driven scoring flows using LLMs for real-time identity enrichment
• Work with BigQuery, Apache Spark, and Apache Iceberg for heavy data processing
• Maintain high-load orchestration with custom Python nodes and complex workflows
• Own deployment and release processes (CI/CD)
• Optimize PostgreSQL performance under heavy load
• Investigate incidents and resolve root causes permanently

• Use AI engineering tools such as Claude in daily development

   

Requirements:

• 4+ years of experience in Data Engineering / Backend Engineering
• Strong Python skills
• Commercial experience with production LLM integration (OpenAI / Anthropic / Gemini)
• Strong knowledge of GCP (Cloud Functions, IAM, Networking)
• Experience with BigQuery, Spark, Iceberg
• Good understanding of Kubernetes
• Experience with workflow orchestration tools (n8n is a strong plus)
• Strong practical knowledge of PostgreSQL

• English level B2+

   

What is important for us:

• Ownership mindset
• Fast learning ability
• Strong problem-solving approach
• Active AI usage in engineering work
• Focus on practical results over unnecessary complexity

We are looking for a Senior Data Engineer to join our team. This is not a standard ETL role. We are building a dynamic data ecosystem where AI is deeply integrated - both as a productivity multiplier and as a core component of our data processing logic for identity data enrichment and data scoring.

You will own the infrastructure that handles over 10,000 executions per minute, ensuring stability, scalability, and data integrity. You will work with a modern stack on Google Cloud Platform, utilizing Cloud Functions and Kubernetes.

We are looking for an engineer who improves infrastructure, automates everything, and is eager to implement LLM-based logic directly into high-load data flows.

Responsibilities

• AI-Driven Data Scoring: Design and implement pipelines that utilize LLMs to analyze and score identity data in real-time. You will integrate AI models directly into the decision-making loop, balancing accuracy with latency and cost.
• Own the Data Architecture: Architect scalable data solutions using GCP and Python. You will manage data storage and retrieval using BigQuery and Apache Iceberg to support querying of TBs of data.
• Heavy Data Processing: Utilize Apache Spark for data transformations and batch processing when lightweight cloud functions are not enough.
• Manage High-Load Orchestration: Maintain and optimize our system instances. It involves complex dataflows, custom Python nodes, and performance tuning for 10k+ execs/minute.
• Release Lifecycle (CI/CD): Take ownership of the deployment process, ensuring that updates to pipelines and infrastructure are released safely with proper testing and rollback strategies.
• Database Optimization: Manage PostgreSQL performance under heavy load, optimizing complex queries and indexing strategies.
• Active AI Usage: Use Claude Code and other AI engineering tools to accelerate your own development, refactoring, and testing processes.
• Incident Resolution: Proactively monitor the system. When alerts fire, you investigate the root cause—whether it’s a database lock or an LLM hallucination—and fix it permanently.
   

Requirements

• 4-5+ years of experience in Data Engineering or Backend Engineering with a strong data focus.
• Production AI Integration: Experience integrating LLMs (OpenAI, Anthropic, Gemini) into production applications via API. You understand latency, token limits, and how to structure data for AI scoring.
• Expertise in GCP: Understanding of Google Cloud Platform (Cloud Functions, IAM, Networking).
• Strong Python: You write clean, efficient, and testable code. You are comfortable building custom logic where standard tools fall short.
• Big Data Stack: Experience with BigQuery, Apache Spark, and modern table formats like Apache Iceberg.
• Kubernetes (K8s): Experience deploying and scaling services in containerized environments.
• Workflow Automation: Understanding of workflow orchestration tools at a deep technical level. N8N is a big part of our domain, so familiarity with it is highly valuable.
• PostgreSQL Mastery: Proven ability to handle heavy write/read loads and optimize schemas.
• English: B2+ (Upper-Intermediate) or higher.
   

Culture & Mindset

• Self-improvement: You are a fast learner. You don't fear AI replacing you; you master it to replace your manual tasks.
• Ownership: You treat the Identity domain as your own business. If a scoring model drifts or a pipeline slows down, you notice it and fix it without being asked.
• Internal Locus of Control: You take responsibility for outcomes. If an external API fails, you build a fallback mechanism instead of just blaming the provider.
• Get It Done: You prioritize shipping value. You know when to use a simple script and when to build a complex architecture.

Openness: You share knowledge freely. If you find a better way to prompt the AI for scoring, you share it with the team.

We are looking for a Senior Data Engineer. This is not a standard ETL role. You will work on a high-load system processing 10,000+ executions per minute, building scalable pipelines where AI and LLM logic are embedded directly into production data flows.

The role combines data engineering, backend thinking, infrastructure ownership, and real production AI integration.

What you will do:

• Design and maintain scalable data pipelines in Python on Google Cloud Platform
• Build and optimize AI-driven scoring flows using LLMs for real-time identity enrichment
• Work with BigQuery, Apache Spark, and Apache Iceberg for heavy data processing
• Maintain high-load orchestration with custom Python nodes and complex workflows
• Own deployment and release processes (CI/CD)
• Optimize PostgreSQL performance under heavy load
• Investigate incidents and resolve root causes permanently

• Use AI engineering tools such as Claude in daily development

   

Requirements:

• 4+ years of experience in Data Engineering / Backend Engineering
• Strong Python skills
• Commercial experience with production LLM integration (OpenAI / Anthropic / Gemini)
• Strong knowledge of GCP (Cloud Functions, IAM, Networking)
• Experience with BigQuery, Spark, Iceberg
• Good understanding of Kubernetes
• Experience with workflow orchestration tools (n8n is a strong plus)
• Strong practical knowledge of PostgreSQL

• English level B2+

   

What is important for us:

• Ownership mindset
• Fast learning ability
• Strong problem-solving approach
• Active AI usage in engineering work
• Focus on practical results over unnecessary complexity

The Go Backend Slot Game Engine Developer is the game-logic authority for the project. The role builds the server-side slot engine from scratch on a Go-based slot Game Development Kit (GDK) and owns it end-to-end — from the math model through integration
review, certification readiness, and live operation on the Remote Gaming Server (RGS) platform.
Scope of ownership covers the slot engine's game logic and mathematics (RTP structure, reel strips, paylines / clusters / Megaways / avalanche, win evaluation), the feature set (buy bonus, ante bet, free spins including retriggers and player-choice, max-win validation), the
paytable and reel/volatility configuration, the RTP simulation and validation harness, and the engine's conformance to the RGS integration contract — the engine lifecycle interfaces, the
spin/keep-generate/replay endpoints, RNG consumed exclusively through the SDK-injected RNG client, and SDK-compliant submission for platform integration review.
Technical Constraints
- Language: Go (1.24+).
- Transport: HTTP and gRPC
- Randomness: all RNG is delegated to the platform RNG service and consumed exclusively through the SDK-injected RNG client. Local or library randomness on game outcomes is treated as Non-Compliance.
- Configuration: reel sets, RTP and volatility externalized to configuration; simulator and runtime parameters via configurations and environment variables. No hardcoded math values in business logic.
- Version control: Git, with Go modules for dependency and version management.
- Local development: engine runs locally and connects to the development platform API via a tunnel; validated against SDK-provided mock services and simulators before submission.
- Deliverable: a compiled engine build submitted through the designated submission process, accompanied by build manifest (version, commit hash, build date), paytable configuration, and a signed SDK compliance statement.
Responsibilities
- Own the slot engine implementation: the engine lifecycle interfaces (spin generation, keep-generate for player-choice sequences, history replay / shown-state logic) and the conversion of game outcomes into the platform's wire model.
- Own the game mathematics: RTP structure, reel strips, paylines / clusters / Megaways, and win evaluation — modelled as the sole server-side authority on probability and outcome, with all probability and balance tables externalized to configuration.
- Own the feature set: buy bonus, ante bet, free spins (fixed, retriggerable, and player-choice), and max-win validation.
- Own the balance configuration tooling: a documented mechanism and config format so Game Design and math can update reel sets, RTP, volatility, and paytable values without code changes.
- Own the RTP simulation and validation harness: run the SDK simulator to prove target RTP, volatility, and max-win behavior, and attach the simulation report to each submission.
- Own SDK compliance and submission: use only documented SDK APIs, implement all required lifecycle methods, conform outgoing payloads to the published event and message schemas, stay within the supported SDK version range, and produce a signed compliance statement per build.
- Drive each build through the platform integration review: package the required submission artefacts, remediate documented review findings, and re-submit until integration is accepted.
- Author and maintain backend documentation: the math/game-logic specification, configuration format, architecture records, and a developer-readable README for the engine.
- Pair with the Game Designer and the client (frontend) team to translate design and GDD
intent into server-feasible, server-authoritative engine specifications.
- Own the engine's quality and security posture: unit-test coverage of game-logic modules, clean SAST/DAST scans, and no secrets in source, fixtures, or commit history.
- Actively use and document the use of AI tools (ChatGPT, Gemini, Claude) to accelerate scaffolding, math modelling, and documentation. Document outcomes alongside prompts so the workflow is reproducible by the team.
Requirements
The position has four hard pillars.
Pillar A — Go Service Architecture and SDK Integration
- Demonstrated ability to design a layered Go service in which the game-logic domain is unit-testable without booting the transport layer, the SDK, or any external service.
- Working knowledge of implementing engine lifecycle interfaces against a provided SDK:
spin generation, continuation (keep-generate) for multi-step sequences, and deterministic reconstruction of stored spins for history replay.
- Discipline in conforming to published event and message schemas, with consistent, well-defined error semantics across the contract.
- Versioning discipline: ability to evolve the engine and its wire payloads without breaking shipped client builds, including a documented deprecation policy, and to stay within the
SDK's supported version range without deprecated calls.
- Ability to externalize hand-tunable parameters (reel sets, RTP, volatility, paytable, limits) through configuration rather than code.
Pillar B — Slot Mathematics and Game Logic
- Demonstrated ability to model probabilistic slot mechanics where the server is the sole authority on probability, tier, and outcome.
- Probability, reel, and balance tables externalized to configuration. Hardcoded math or balance values inside business logic are treated as Non-Compliance.
- Currency and award math: integer or fixed-point arithmetic for all wager, balance, and award operations. Floating-point arithmetic on monetary values is treated as Non-Compliance.
- All randomness consumed exclusively through the SDK-injected RNG client; no local or library RNG on game outcomes.
- Working knowledge of common slot mechanics: paylines (left-to-right / right-to-left), clusters, Megaways, avalanche/cascades, free spins (fixed, retriggerable, player-choice), buy bonus, and ante bet, with max-win validation.
Pillar C — Determinism, Compliance, and Integrity
- Demonstrated ability to guarantee deterministic replay: a stored spin must reconstruct to an identical, player-visible state on history replay.
- Anti-abuse posture: idempotency for retry-prone operations, replay resistance.
- SDK compliance discipline: use of only documented APIs, no private or undocumented endpoints, correct lifecycle implementation, and a signed compliance statement per build.
- Secret-handling discipline: no secrets, signing keys, or credentials in source, fixtures, or commit history; awareness of and mitigation for common (OWASP Top 10) vulnerability categories.
Pillar D — Simulation, Performance, and Reliability
- Demonstrated ability to run large-scale spin simulation to validate statistical targets (RTP, volatility, hit rate, max-win) and to produce a reproducible simulation report.
- Working understanding of latency and throughput budgets for spin endpoints, including how serialization, allocation, and hot-path design affect them.
- Profiling expertise on a Go service: ability to localize latency or contention using application-level traces, profiling tools (e.g. pprof), and load-test evidence.
- Observability discipline: structured logs with correlation IDs across requests and metrics on the relevant endpoints.
- Testing discipline: unit-test coverage of game-logic modules with clean SAST/DAST scans.

We are looking for an Integration Engineer to design, build, and maintain reliable integrations between our advertising platform and external marketing services.
 

What you will do

— Develop and maintain integrations with Meta Marketing API and LinkedIn Marketing API: rate limits, async reports, breakdowns, attribution windows.

— Build and support data synchronization pipelines from Ad Platform APIs to BigQuery/ClickHouse via Cloud Run Jobs and n8n workflows.

— Ensure reliability of data sync: error handling, retry strategies, monitoring and alerting.

— Work with API rate limits, OAuth flows, and webhooks across advertising platforms.

— Participate in new integration projects from API evaluation through production rollout.

— Write production-grade Python code: error handling, logging, tests, documentation.

— Actively use AI-assisted development tools (Copilot, Cursor, Claude Code) for code generation, debugging, and pipeline design.
 

Requirements

— 5+ years in backend or data engineering with focus on API integrations.

— Hands-on experience with Meta Marketing API and/or LinkedIn Marketing API: real work with rate limits, async reports, breakdowns, attribution windows.

— Strong Python skills: production-grade code with error handling, logging, and tests.

— Solid understanding of data pipeline patterns: idempotency, backfill, incremental sync, schema evolution.

— Experience with GCP or comparable cloud (AWS/Azure) at service level: Cloud Run, BigQuery, or equivalents.
 

Nice to Have

— Knowledge of Programmatic ecosystem: DV360, The Trade Desk, OpenRTB.

— Experience with BigQuery and/or ClickHouse.

— Pulumi / Terraform for IaC.

— Understanding of advertising metrics: impressions, clicks, conversions, ROAS, attribution models.

— Experience with n8n or similar workflow orchestration tools.
 

What We Offer

— Fully remote with flexible hours (aligned with EU timezones for syncs).

— AI-first tooling — Claude Code licenses and cutting-edge AI development workflows.

— A team with no bureaucracy, decisions are made fast.