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}
Ur/Web is an esoteric, purely functional web framework designed for building statically-typed, SQL-integrated web applications with extraordinary safety guarantees. Unlike mainstream web frameworks, Ur/Web eliminates entire classes of bugs at compile time: no SQL injection, no type mismatches, no cross-site scripting vulnerabilities by default. Hiring an Ur/Web developer means getting someone who deeply understands functional programming, type systems, and formal correctness in web applications. South connects you with specialized Ur/Web developers who have shipped secure, correctness-focused applications. Ready to build with guarantees? Get started with South today.
Ur/Web is a domain-specific language and web framework created by Adam Chlipala, designed for building web applications with strong static typing and compile-time safety. It's built on a dependently-typed language and provides integrated support for SQL, HTML, CSS, and JavaScript generation, all type-checked at compile time.
The key innovation is that Ur/Web prevents entire categories of web vulnerabilities through the type system: SQL injection is impossible (queries are type-checked), cross-site scripting is prevented (HTML generation is type-safe), and client-server communication is fully typed. This is fundamentally different from mainstream frameworks like Rails or Django, which rely on runtime discipline.
Ur/Web is used by companies building applications where correctness is paramount: financial systems, healthcare platforms, and systems handling sensitive data. The language compiles to efficient C code and JavaScript, achieving performance comparable to hand-written code while providing formal guarantees. A typical Ur/Web codebase is 30-50% smaller than equivalent applications in other languages, due to the type system catching bugs early.
The downside: Ur/Web has an extremely small talent pool globally. Most developers are academics, researchers, or engineers at companies with specific formal methods requirements. Learning Ur/Web requires understanding dependent types, which is a significant conceptual leap from mainstream programming.
Hire an Ur/Web developer only if you have existing Ur/Web code or a specific requirement for compile-time safety guarantees that no other technology stack can provide. If you're building a system handling sensitive data (financial transactions, health records, authentication systems), and you want to eliminate entire classes of vulnerabilities, Ur/Web is worth considering.
Do not hire for Ur/Web if you're starting a new project and considering it as a general-purpose web framework. The tiny talent pool, steep learning curve, and limited ecosystem make it impractical for most teams. Instead, use mature frameworks like Django, Rails, or Fastapi with disciplined security practices.
If you do hire Ur/Web developers, they typically come as part of a specialized team or consulting engagement. A single Ur/Web developer on a team of Rails developers will face isolation and friction. Ur/Web works best for dedicated, mission-critical systems where the team is fully bought into the correctness-first philosophy.
Typical team composition: 2-4 specialized developers with strong functional programming backgrounds, paired with security consultants or formal methods experts who can guide architecture decisions. Many organizations hire Ur/Web developers through consulting firms rather than direct employment.
Look for candidates with published Ur/Web projects, academic backgrounds in type theory or formal verification, or experience with other dependently-typed languages (Idris, Agda, Coq). In this niche, academic credentials and published work are more reliable signals than years of experience.
Assess their understanding of dependent types and functional programming paradigms. Questions should probe: How do you think about type-driven development? How would you design an API that makes invalid states unrepresentable? Can you explain the difference between parametric and dependent types? Good answers demonstrate deep theoretical understanding, not just syntax knowledge.
Red flags: candidates who view Ur/Web as just another web framework, or who can't explain why compile-time guarantees matter. Another red flag is developers claiming Ur/Web expertise without being able to discuss the type system or formal verification aspects.
Junior (1-2 years): Can write basic Ur/Web applications with guidance, understands type signatures, can implement simple type-safe queries. Requires significant mentorship on formal methods and type-driven design.
Mid-level (3-5 years): Can architect type-safe systems, design APIs that make invalid states unrepresentable, optimize type checking performance. Understands the philosophy behind dependent typing.
Senior (5+ years): Can mentor teams on correctness-first design, architect complex formal systems, contribute to language tooling or compiler. Often has academic publication record.
Soft skills: Strong communication is critical because Ur/Web developers need to explain correctness arguments to teams unfamiliar with formal methods. Patience with non-specialists is essential.
Tell us about a time you used types to prevent a bug that would have been caught at runtime in other languages. Strong answer: specific example, clear explanation of the type system preventing the issue, understanding of compile-time vs runtime. Weak answer: vague or generic understanding.
You're designing an API. How do you use the type system to make invalid states unrepresentable? Strong answer: discusses dependent types, refinement types, phantom types. Shows design thinking focused on correctness. Weak answer: focuses only on documentation or tests.
Walk us through your approach to learning a new formal verification tool. Strong answer: systematic learning, reading research papers, implementing examples, understanding the theoretical foundations. Weak answer: treats it like learning a standard library.
Describe a security vulnerability you've prevented through type safety. Strong answer: specific example (SQL injection prevention, XSS prevention, type mismatches), explanation of how the type system caught it. Weak answer: abstract benefits without concrete examples.
How do you explain dependent types to a developer from a mainstream language background? Strong answer: clear analogy, builds from familiar concepts, acknowledges difficulty. Weak answer: overly theoretical without accessible explanation.
Explain the concept of dependent types. How would you use them to represent a list with a known length at compile time? Tests: understanding of type theory, practical application to real problems. Score: clarity and correctness of explanation.
Design a type-safe database schema in Ur/Web. How would you prevent SQL injection and ensure referential integrity at compile time? Tests: understanding of Ur/Web's SQL integration, type-driven design. Score: completeness and elegance of type signatures.
What's the difference between parametric and dependent types? When would you use each? Tests: theoretical understanding, practical judgment. Score: nuance and accuracy.
How would you design an API for validated email addresses that makes invalid emails unrepresentable in the type system? Tests: refinement types, dependent types, practical API design. Score: practical thinking plus type-theoretic rigor.
Write an Ur/Web fragment that demonstrates type-safe query generation with compile-time foreign key checking. Tests: Ur/Web syntax, SQL integration, type system usage. Score: correctness and elegance.
Challenge: Design a type-safe banking transaction system where overdrafts are impossible (cannot represent negative balances at the type level) and all transfers are audited. Show type signatures. Score: uses dependent types or refinement types effectively, prevents invalid states through the type system, design is elegant and maintainable.
Ur/Web developers command premium rates due to extreme scarcity and specialized expertise. Most are mid-to-senior consultants or researchers.
Mid-level (3-5 years): $60,000-$85,000/year
Senior (5+ years): $90,000-$130,000/year
Specialist/Consultant (8+ years): $130,000-$180,000/year
US-based Ur/Web developers command $100,000-$200,000+ depending on expertise and consulting relationships. LatAm rates represent 40-50% savings while accessing the tiny global Ur/Web talent pool.
Note: LatAm has limited Ur/Web expertise. Most developers are in academic positions or working for international companies. Hiring typically involves consulting arrangements rather than full-time employment.
LatAm universities, particularly in Brazil and Argentina, have strong computer science programs with functional programming emphasis. Some academic groups focus on formal methods and dependently-typed languages. This creates a small but highly qualified pool of Ur/Web specialists.
Time zone overlap: LatAm developers are UTC-3 to UTC-5, giving 6-8 hours overlap with US East Coast. Sufficient for daily coordination on formal specification and design.
English proficiency among academic and specialized developer communities is strong. These developers publish in English, attend international conferences, and are comfortable with technical communication.
Cost efficiency for specialized expertise: An Ur/Web developer from LatAm costs 40-50% less than US equivalents while bringing the same formal methods training and correctness-focused mindset.
Selection advantage: By hiring from LatAm's academic developer pool, you access theoretically grounded engineers who view correctness as paramount, not an afterthought.
Given Ur/Web's extreme niche status, hiring typically involves multiple conversations. Tell us: Do you have existing Ur/Web code? What are your correctness requirements? Are you open to consulting vs full-time arrangements?
South maintains relationships with formal methods researchers and specialized developers across LatAm. When you're ready, we connect you with 1-3 candidates who have demonstrated Ur/Web expertise through published work, conference presentations, or shipped projects.
Onboarding is more involved than typical hires. We ensure deep alignment on correctness philosophy, formal methods approach, and long-term technical vision. This is partnership, not just hiring.
Our 30-day guarantee applies, but for Ur/Web hires, the first 30 days are mutual evaluation: you learn their approach, they learn your requirements, you confirm alignment before extending.
Ready to hire? Start your search with South.
Building web applications with compile-time safety guarantees. Specifically: applications where SQL injection, XSS, and type mismatches are unacceptable; systems handling sensitive data; correctness-critical platforms like financial systems or healthcare.
Only if correctness is your primary requirement and your team embraces formal methods. For most teams, mainstream frameworks with disciplined security practices are more practical.
Use Ur/Web when compile-time correctness proofs matter more than developer familiarity. Use mainstream frameworks when you need a large talent pool and rapid iteration.
Mid-level: $60K-$85K/yr. Senior: $90K-$130K/yr. Specialist: $130K-$180K/yr. 40-50% less than US equivalents.
2-4 weeks. The talent pool is tiny and most developers are deep in other projects. We need time to identify and discuss with potential candidates.
Possible, but challenging. Ur/Web developers think differently about problems. Isolation from the rest of your team can be frustrating. Consider: Is their system truly isolated? Can they mentor the team on correctness thinking?
Possible but less common. Most Ur/Web work is project-based or consulting. Minimum 3-month engagements work better than short-term.
UTC-3 to UTC-5 (mostly Brazil, Argentina). 6-8 hours overlap with US East Coast. Some developers extend hours for Pacific US coverage.
Portfolio review (published projects, conference talks, academic papers), technical interviews focused on type theory and formal methods, assessment of correctness thinking, references from previous employers or academic advisors.
30-day replacement guarantee applies. For Ur/Web, the first month is mutual evaluation: you learn their approach, they learn your system. If misalignment emerges, we source a replacement.
Yes, though team-building is more strategic. We can identify 2-4 Ur/Web specialists for a mission-critical system. Expect longer sourcing timelines.
