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}
Preact is a lightweight JavaScript framework that implements the same virtual DOM API as React but with a minimal footprint. It's 12x smaller than React while maintaining near-identical component patterns, hooks, and JSX syntax. If you know React, you know Preact.
Preact's strength is performance in bandwidth-constrained environments. It's used by companies building for emerging markets, IoT devices, and edge computing. Google uses it in some projects, and Shopify has explored Preact for performance-critical flows.
The framework introduced Signals, a reactive state management primitive that's now being adopted by other frameworks. Signals provide automatic dependency tracking without React's re-render cycle, meaning smaller bundles and faster updates.
Preact 10+ added hooks support, making it feature-parity with modern React for most use cases. The ecosystem includes Preact Router for SPAs, Preact Signals for state management, and growing support in build tools like Vite and esbuild.
Where Preact wins: performance-obsessed teams, mobile web, micro-frontends, and projects targeting developing regions where 3G is the norm. Where it loses: companies already invested in React tooling and teams that need React's extensive third-party ecosystem.
Hire Preact when bundle size is a business metric. Building an e-commerce site where Core Web Vitals directly impact conversion? Preact can reduce your JavaScript bundle by 30-40%, translating to measurable improvements in page speed and user retention. This matters for SEO and revenue.
Use Preact for PWAs and offline-first applications. The small bundle means faster app install, better offline caching, and less network churn. Perfect for mobile-first products targeting developing markets.
Preact is ideal for micro-frontend architectures where you're embedding multiple JavaScript applications on a single page. Each micro-app can be a Preact bundle without JavaScript bloat.
Use Preact when you need React skills but can't justify React's overhead. Teams familiar with React can switch instantly. It's not a different paradigm, just optimized.
Don't use Preact if you rely heavily on React-specific libraries like Redux, React Query, or Material-UI that don't have Preact equivalents. You'll spend time porting or finding alternatives.
Team composition: A single Preact developer can own a full PWA or performance-critical interface. Pair with backend developers in Node, Python, or Go. For larger applications, pair Preact with state management specialists if using Signals.
Look for developers comfortable with both React and performance optimization. They should understand the virtual DOM, JSX, and hooks. But they should also understand why a 3 KB library matters more than a 40 KB one.
Performance consciousness is non-negotiable. Can they talk about bundle size budgets? Do they profile JavaScript execution? Do they care about Core Web Vitals? A good Preact developer thinks constantly about what they're shipping to the browser.
They should have shipped production Preact or React code. Ask about their largest project. What was the performance improvement compared to heavier frameworks?
Building skills matter. Are they comfortable with esbuild, Vite, or Rollup? Can they optimize images, lazy-load routes, and manage dependencies? Preact teams often own the entire build pipeline.
Junior (1-2 years): Comfortable with React components, hooks, and basic Preact patterns. Understands JSX and component lifecycle. Shouldn't be optimizing complex build pipelines yet.
Mid-level (3-5 years): Can architect large Preact applications, optimizes bundle size proactively, understands when to use code splitting and lazy loading, comfortable with build tools, can mentor juniors on performance patterns.
Senior (5+ years): Deep understanding of virtual DOM performance, can architect micro-frontend systems, optimizes for Core Web Vitals, understands browser rendering pipeline, comfortable teaching performance optimization to teams.
Tell me about the last time you optimized a web application for performance. What did you measure, and what was the result? Good answers include specific metrics (Largest Contentful Paint, First Input Delay, bundle size reduction). They should mention tools like Lighthouse or WebPageTest.
Why would you choose Preact over React? Listen for bundle size as the primary reason, not just "it's smaller." They should articulate specific trade-offs and use cases.
Describe your experience with build tools. What's a challenging optimization you've implemented? Look for code splitting, tree shaking, dynamic imports. Good answers include specific examples with measurable improvements.
How do you approach debugging performance issues in a Preact application? They should mention browser DevTools, performance profiles, and identifying JavaScript bottlenecks. Good answers include systematic approaches, not guessing.
Tell me about a time you had to make a trade-off between developer experience and performance. This reveals judgment. Smart developers know when to optimize and when to move fast.
In Preact, how does the virtual DOM diff algorithm work, and why does it matter? Correct answer: Preact walks the virtual tree, compares with the actual DOM, and applies minimal changes. Good answers explain why fewer DOM mutations equals better performance.
What's the difference between React and Preact, and what trade-offs does Preact make? Preact removes some error boundaries, context improvements, and other React features. They're more confident about the architecture if they know specific omissions.
How would you implement code splitting in a Preact application, and what's the performance impact? They should describe dynamic imports, lazy components, and route-based splitting. Good answers include metrics on reduced initial bundle size.
Explain how Preact Signals differ from React state. When would you use each? Signals are reactive and don't trigger component re-renders. They're more efficient for global state. React state triggers renders. Signals for derived values, useState for component-local state.
How do you handle third-party React libraries in a Preact application if they're not compatible? Common patterns: find Preact alternatives, fork and adapt, or use compatibility layers. They should know compatibility isn't guaranteed.
Build a Preact component that fetches a list of items and displays them with lazy loading. Measure and optimize the bundle size. 45 minutes. Look for: correct Preact hooks, lazy loading implementation, bundle size awareness. Advanced: implement route-based code splitting. Score: basic component plus lazy loading equals passing. Optimized bundle with tree shaking equals strong.
Preact developers are typically React developers with performance specialization, so salaries align with React rates, sometimes 5-10% higher due to specialization. LatAm rates vary by country and seniority.
Compare to US rates: a senior Preact/React developer in the US costs $140,000-$240,000+ per year. LatAm talent gives you 40-60% savings. Preact specialists, because they're less common, sometimes command a 10% premium over generalist React developers.
LatAm has a strong React talent pool that easily translates to Preact. The regional focus on performance and optimization due to emerging market constraints (slower networks, older devices) makes LatAm developers particularly adept at Preact patterns.
Time zones align well. Most LatAm developers are UTC-3 to UTC-5, giving you 6-8 hours of overlap with US East Coast and 3-5 hours with West Coast. Real-time collaboration is feasible.
Cost efficiency is substantial. You can hire 2-3 LatAm developers at the cost of a single US senior. For performance-critical products where optimization cycles are constant, this team bandwidth pays for itself.
LatAm developers often have experience optimizing for bandwidth-constrained environments. If you're expanding to developing markets, hiring developers who've built for those constraints is invaluable.
Share your requirements with South: seniority, performance targets, bundle size budget, any existing codebase preferences. We search our network of React and Preact specialists across Brazil, Argentina, Colombia, and beyond.
Our matching process includes performance-oriented technical interviews. We ask about Core Web Vitals optimization, bundle analysis, and specific Preact patterns. This ensures you get developers who care about performance, not just framework knowledge.
You interview candidates directly through South's coordination. Our process focuses on shipped projects and measurable performance improvements, not theoretical knowledge.
Hire directly or through South's managed service. Direct hire gives you full control; managed service handles payroll, compliance, and ongoing support. Either way, our 30-day guarantee applies.
Start building fast and light. Connect with Preact developers through South.
Preact is used for performance-critical web applications, PWAs, embedded interfaces, micro-frontends, and products targeting users on slow networks or older devices. Anywhere bundle size and startup time matter.
Yes, if performance is a business metric and your team knows React. No, if you rely on React ecosystem libraries (Redux, Material-UI, React Query) without Preact alternatives.
React if you need the ecosystem and can afford the bundle size. Preact if you're optimizing for mobile web, PWAs, or have strict performance budgets. Preact is React but smaller.
Mid-level costs $52,000-$72,000 annually in Brazil. Senior costs $80,000-$115,000. These are 40-60% cheaper than US rates.
Typically 1-2 weeks. Preact developers are often experienced React developers, so we have a good supply.
For a standard Preact project, mid-level is sufficient. For performance optimization at scale, hire senior. Staff-level specialists are rare.
Yes. South works with developers available for contract, part-time, and full-time roles. Short-term (under 3 months) is possible but costs more.
Most are UTC-3 (São Paulo, Buenos Aires) or UTC-5 (Colombia). This provides 6-8 hours of overlap with US East Coast.
We pair program on performance optimization challenges, review shipped projects, and ask about bundle analysis and optimization. We prioritize results over certifications.
You have 30 days to evaluate. If they're not right, we replace them at no cost.
Yes, through our managed service. We handle contractor agreements, local tax, benefits, and compliance.
Yes. South places Preact teams: typically one senior architect/performance lead, 2-3 mid-level developers, and supporting roles. Cost is 40-50% cheaper than equivalent US team.
