We source, vet, and manage hiring so you can meet qualified candidates in days, not months. Strong English, U.S. time zone overlap, and compliant hiring built in.
.svg){kind=logo}
Starlark is a Python-inspired language designed for configuration and scripting in the Bazel build system. If your organization uses Bazel for large-scale polyglot builds or needs maintainable, reproducible build infrastructure, Starlark developers from South bring deep build systems expertise combined with Python-like clarity. Hire Starlark specialists when build complexity threatens your deployment velocity.
Starlark (formerly called Skylark) is a small, dynamically-typed language inspired by Python but designed specifically for writing build rules and configuration. Created as part of the Bazel build system, it's used to define how code gets compiled, tested, packaged, and deployed. Unlike shell scripts or Make, Starlark is strongly structured: it has lexical scoping, first-class functions, and reproducible execution semantics that make builds deterministic.
Google uses Starlark internally at massive scale. Other major users include Stripe, Lyft, and companies running polyglot monorepos where managing heterogeneous build requirements is a business problem. Starlark is also used outside Bazel in other build tools (BuildBuddy, Pants) and configuration management systems. If you have hundreds of services written in different languages and need a single, understandable build definition, Starlark is your answer.
The LatAm Starlark talent pool is smaller than mainstream languages but concentrated in companies that use Bazel: fintech firms, large tech companies, and open source projects. These are developers who've grappled with build complexity at scale and understood that fixing builds is not a side project—it's infrastructure engineering.
Hire Starlark developers when your build infrastructure has become unmaintainable: when Make or shell scripts no longer scale, when reproducing builds is hard, when onboarding new developers includes a "here's how to set up your environment" guide. If your organization has multiple services in different languages and build tool proliferation is becoming a team productivity drain, Starlark and Bazel are the answer.
Starlark excels in monorepos, microservice architectures, and polyglot teams. A company with Python backends, Go services, TypeScript frontends, and Rust infrastructure components can define a single Bazel/Starlark build system that handles all of them consistently. This creates reproducible, cacheable builds that accelerate developer velocity and CI/CD.
Starlark is NOT the right choice if you have a simple project (single language, traditional monolith). It's also not appropriate for deployment orchestration or runtime configuration—Starlark is for build time, not runtime. If you're just looking for a scripting language, use Python. If you're looking for configuration management, use Terraform or Ansible. Starlark is laser-focused on builds.
Team composition: Starlark developers work best alongside DevOps engineers and platform teams who understand CI/CD infrastructure. They should pair with service owners who understand build requirements for different languages and frameworks. Starlark work is usually centralized (build platform team) but highly visible—every engineer touches the build system daily.
Strong Starlark developers have deep build systems knowledge. They should be able to explain what makes a build deterministic, understand caching semantics, and know when to use certain Bazel concepts (rules, targets, genrules). Look for evidence of previous build infrastructure work: maintaining complex Makefiles, using Gradle, Bazel, or other advanced build tools. Red flags: developers who've only written application code and are learning Starlark as a side skill; build infrastructure is not junior work.
Portfolio work should show complex, real-world build definitions: multi-language targets, custom rules, integration with external tools. They should be comfortable reading Bazel source code and understanding how build rules compose.
Junior (1-2 years): Understands Starlark syntax, can write simple build rules, knows basic Bazel concepts. May need guidance on advanced patterns, performance optimization, and cross-language builds.
Mid-level (3-5 years): Designs complex build systems, writes custom rules, optimizes for caching and parallelism. Has maintained or extended Bazel infrastructure supporting multiple languages. Understands build performance profiling and can diagnose slow builds.
Senior (5+ years): Architects organization-scale build platforms, mentors on build philosophy and best practices. Contributes to Bazel ecosystem, understands advanced concepts like remote execution and build federation.
Tell me about the most complex Starlark rule set you've built. What made it complex, and how did you simplify it? Listen for: specific architecture, understanding of Bazel concepts, and pragmatism about simplification. They should discuss composition, avoiding rule proliferation, and keeping configurations maintainable.
Describe a time you had to migrate a large codebase from one build system (Make, Gradle, etc.) to Bazel/Starlark. What was hard about it? Strong answers discuss incrementalism, maintaining developer productivity during migration, handling legacy build logic, and breaking dependencies. This separates experienced build engineers from those who've only used Bazel on new projects.
Walk me through your approach to debugging a slow build. How would you identify the bottleneck? Good answers discuss profiling tools (bazel analyze-profile), understanding cache hits/misses, parallelism opportunities, and remoting. They should show systematic thinking about performance investigation.
Tell me about a time your Starlark code made the build system faster or more reliable. What was the problem, and how did you solve it? Listen for: concrete metrics (build time reduction, cache hit rate improvement), understanding of what "reliable" means (reproducibility, determinism), and technical depth in the solution.
How do you approach teaching someone to think about build systems and configuration? For senior candidates, listen for: ability to explain why Starlark is structured the way it is, pragmatism about learning curve, and techniques for building intuition about determinism and caching.
Write a simple Starlark rule that runs a Python script and produces an output file. Now extend it to handle multiple languages (Python and Go). Evaluate: correct Starlark syntax, understanding of inputs/outputs, action generation, and proper attribute definition. They should show awareness of hermetic execution and dependencies.
Explain the difference between eager and lazy evaluation in Bazel. Why does Bazel use lazy evaluation? They should understand that lazy evaluation enables incremental builds, caching, and parallel execution. They should discuss how this affects rule design and performance.
You're designing a custom rule for a microservice that needs to be packaged as a Docker image, deployed to Kubernetes, and tested. Sketch the rule architecture. Evaluate: understanding of rule composition, proper dependency declaration, integration with external tools, and testability. Strong answers discuss aspect-based testing and reproducibility.
Design a Starlark configuration for a monorepo with services in Python, Go, and TypeScript. How would you make the build system consistent and cacheable across languages? Listen for: understanding of language-specific tooling, shared build patterns, configuration reuse, and practical considerations (build time, maintainability).
How would you handle a situation where adding a new build rule or feature breaks existing builds across the monorepo? They should discuss migration strategy, backwards compatibility, deprecation warnings, and communication to affected teams. This tests architectural thinking and empathy for build consumers.
Write a Starlark rule that compiles a simple Go program and produces a binary. Then extend it to run the binary as a test. Scoring: correct Bazel/Starlark syntax, proper attribute specification, correct inputs/outputs declaration, understanding of action generation, and explanation of how the rule ensures reproducibility.
Junior (1-2 years): $30,000-$42,000/year in LatAm. These are developers with build systems fundamentals and scripting experience, new to Bazel/Starlark.
Mid-level (3-5 years): $48,000-$70,000/year in LatAm. Developers with shipped Bazel/Starlark infrastructure supporting multiple languages and teams.
Senior (5+ years): $75,000-$105,000/year in LatAm. Experienced build platform architects with organization-scale infrastructure experience.
Staff/Architect (8+ years): $110,000-$150,000/year in LatAm. Rare experts contributing to Bazel ecosystem or designing build federation systems.
US Starlark developers cost $70,000-$130,000 at mid-level and $140,000-$220,000 at senior. LatAm talent offers 45-50% savings while maintaining the same build systems rigor. Starlark expertise is concentrated in large tech companies and fintech; LatAm has growing Bazel adoption creating talent pipeline.
LatAm has increasing adoption of Bazel and build infrastructure tooling, especially in fintech and large tech companies operating in the region. Brazil and Argentina have strong software engineering cultures in companies like Mercado Libre, Nubank, and others using Bazel. This creates talent pipeline where developers have real production experience with large-scale builds.
Most LatAm Starlark developers are UTC-3 to UTC-5, giving excellent overlap with US teams. Build infrastructure work often requires synchronous collaboration—developers modifying build definitions need quick feedback on impact across the organization.
English proficiency is strong. Build systems work involves reading documentation, understanding complex architecture, and collaborating across distributed teams—all requiring fluent technical communication.
Cost savings are substantial (45-50%), and you're hiring from the same talent pool that's shipped Bazel at scale. The difference is geographic, not experience level. Large companies in LatAm have infrastructure teams just as sophisticated as those in North America.
Describe your build infrastructure challenges: How many services? How many languages? What are the biggest pain points (slow builds, hard to test, difficult to onboard)? South's network includes build platform engineers and Bazel specialists across LatAm tech companies and infrastructure teams.
South matches you with pre-vetted Starlark developers, each with relevant experience (monorepos, polyglot builds, performance optimization). You interview them on build philosophy, past projects, and approach to infrastructure design. South handles logistics and contract.
Once matched, South manages the relationship with a 30-day guarantee. If the developer isn't right, we replace them at no cost.
Ready to fix your build system? Start your match with South today.
Starlark is used to write build rules and configuration for the Bazel build system. You define how code gets compiled, tested, packaged, and deployed. It's designed for reproducible, cacheable builds in large, polyglot codebases.
Use Bazel/Starlark if you have a complex build landscape (multiple languages, monorepo, many services) where build management has become a productivity burden. If you have a simple project, traditional tools (Make, Maven) are sufficient.
Groovy is more flexible and closer to full programming language semantics; Starlark is simpler, more deterministic, and designed for large-scale reproducibility. Choose Starlark for monorepos and polyglot builds; choose Gradle for JVM-centric projects.
Mid-level developers cost $48,000-$70,000/year; seniors run $75,000-$105,000/year. This is 45-50% less than equivalent US talent.
Typical timeline is 3-4 weeks. Build infrastructure expertise is specialized but growing in LatAm tech.
For migrating to Bazel, hire mid-level or senior. For maintaining existing build infrastructure, mid-level is sufficient. Junior developers can contribute under oversight.
Yes. South matches developers for project-based and part-time work. Build migration projects often have natural phases suitable for part-time engagement.
Most are UTC-3 to UTC-5 (Brazil, Argentina), providing strong US overlap.
South reviews their build systems experience, assesses past Bazel/Starlark projects, and discusses their approach to infrastructure design. Vetting focuses on systems thinking and production rigor.
South's 30-day guarantee covers this. If they don't work out, we replace them at no cost.
Yes. South manages all contracts, payroll, and employment compliance.
Yes. South can source multiple build engineers, though the talent pool is specialized. We recommend starting with 1-2 mid-to-senior developers who can architect your build platform.
Python Developers — Starlark shares Python syntax; pairing a Starlark specialist with Python engineers streamlines build logic integration.
Go Developers — Go services in monorepos require custom Starlark build rules; Go expertise plus Starlark skills is a powerful combination.
DevOps Engineers — Build infrastructure integrates with CI/CD pipelines; pairing Starlark developers with DevOps engineers ensures seamless deployment integration.
