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}
Bottle is a fast, simple, and lightweight Python web framework that emphasizes minimalism and simplicity. A single-file framework with zero external dependencies (only Python standard library for core functionality), Bottle is perfect for building REST APIs, microservices, and simple web applications. It routes requests, renders templates, and serves static files with remarkable efficiency and clarity.
Bottle provides routing, request/response handling, and template rendering in a single Python file with no external dependencies. This radical simplicity appeals to developers who want to understand every line of code in their framework and avoid dependency bloat. Released in 2009 by Marcel Hellkvist, Bottle has remained intentionally minimal while other Python frameworks (Django, Flask) grew feature-rich ecosystems.
Bottle competes primarily with Flask in the lightweight Python web framework space. While Flask added Blueprints, Extensions, and became more opinionated, Bottle maintained its single-file simplicity. Bottle applications are typically smaller, more explicit, and easier to understand. It's used by companies building APIs and internal tools where framework overhead is a liability rather than an asset.
In the LatAm developer market, Bottle is niche. Most Python developers learn Django or Flask first. Bottle developers are typically senior developers who have chosen it consciously for specific projects (REST APIs, embedded systems, microservices where minimal footprint matters). You'll find Bottle expertise concentrated among experienced Python developers.
Hire Bottle if you're building REST APIs or microservices where framework overhead is undesirable. Bottle's simplicity means fewer moving parts to debug, minimal configuration, and direct control over HTTP semantics. If you're building a simple service that receives requests, processes them, and returns JSON, Bottle's directness is refreshing compared to more opinionated frameworks.
Bottle is ideal if you're embedding Python in embedded systems, IoT devices, or serverless functions where every byte and CPU cycle matters. A Bottle application can be deployed with minimal dependencies. It runs efficiently in constrained environments.
Bottle works well for internal tools, prototypes, and systems where you want maximum clarity and maintainability. The single-file approach means everything is visible, with no hidden magic or framework conventions to learn. If your team values transparency and control, Bottle rewards that.
Do not hire Bottle for large, complex applications requiring many third-party extensions. If you need authentication, ORM integration, admin panels, and form generation out of the box, Flask or Django are better choices. Bottle's minimalism becomes a liability when you end up reimplementing common features.
Team composition: Bottle developers typically work on smaller, focused services. Pair with a DevOps or SRE engineer comfortable deploying simple Python applications. If you're building a microservices architecture, Bottle developers work alongside other service teams (some might use Node.js, Go, or other technologies). Bottle pairs well with experienced Python developers who understand networking and HTTP.
Look for developers who appreciate simplicity and can articulate why Bottle is the right choice for a specific project. The best candidates understand HTTP semantics (status codes, headers, routing) deeply because Bottle doesn't abstract them away. They're comfortable with decorators, Python generators, and context managers (core to Bottle's elegant API).
Evaluation areas: Can they build a working REST API from scratch with Bottle? Do they understand request routing, parameter handling, and response generation? Can they integrate with databases (SQLAlchemy, raw SQL)? Are they comfortable with Bottle's template system or would they use it for JSON APIs only? Can they deploy Bottle applications? Do they understand WSGI?
Junior (1-2 years): Can build simple Bottle routes and handle basic requests/responses. Understands decorators and routing. May need guidance on production deployment, security, or integrating with databases. Likely still learning when Bottle is appropriate versus other frameworks.
Mid-level (3-5 years): Can architect REST APIs with Bottle, handle routing complexity, integrate with databases, and implement basic middleware. Understands HTTP status codes and error handling deeply. Can deploy Bottle applications to production. Comfortable with JSON serialization and API design patterns. Can troubleshoot request/response issues.
Senior (5+ years): Deep understanding of HTTP and REST API design, with Bottle chosen consciously for specific problem domains. Can architect microservices platforms using Bottle. Understands WSGI deployment, performance optimization, and production concerns (logging, monitoring, error handling). Can mentor junior developers and make architectural decisions about when Bottle is appropriate versus alternatives.
Remote readiness: Look for developers comfortable working independently on focused services and communicating clearly about API contracts and deployment. Bottle projects often involve clear boundaries and well-defined interfaces.
Tell me about a REST API you built with Bottle. Why did you choose Bottle over Flask or Django? A good answer articulates specific reasons (simplicity, minimal dependencies, clarity, performance constraints). This reveals whether the developer chose Bottle consciously or just happened to use it. Weak answers suggest they don't understand framework tradeoffs.
Describe a situation where you had to implement a feature in Bottle that would be trivial in Django. How did you handle it? This tests whether the developer understands Bottle's minimalism as a tradeoff. Strong answers show problem-solving and understanding that Bottle requires more manual work. Weak answers suggest the developer struggles with Bottle's lack of batteries.
How do you approach testing in Bottle applications? Walk through your testing strategy for an API endpoint. Look for answers about request/response simulation, mocking, and clear test structure. Bottle's simplicity makes testing straightforward, so good developers have clean testing practices.
Have you deployed Bottle applications to production? What were the deployment challenges, and how did you address them? This separates developers who've shipped Bottle apps from those who've only built demos. Production challenges might include WSGI server choice, static file handling, logging, and monitoring.
What's your experience with Bottle's template system? When would you use it versus building a JSON API? A good answer shows the developer understands Bottle works for both server-rendered and API-only applications, and they can decide which approach fits the problem.
Explain how Bottle routing works. How would you implement a route that accepts variable path parameters? Correct answer describes decorators (@app.route('/users/
Build a simple REST API endpoint in Bottle that accepts JSON, validates it, saves to a database, and returns JSON. How would you handle errors? Evaluate for: proper route definition, request parsing (bottle.request.json), validation, error handling, response generation (abort, returning dicts). Can they write production-quality code? Do they consider edge cases?
How does Bottle handle HTTP headers and cookies? Write code to set a cookie in a response. Candidates should understand bottle.response object, how to set headers and cookies, and security considerations (httponly, secure flags). Senior developers discuss cookie security and best practices.
Explain Bottle's approach to middleware. How would you add logging or authentication middleware? Bottle uses decorators for middleware. Candidates should understand function wrapping, request/response interception, and when to use plugins versus decorators. Strong answers discuss the plugin system.
What's WSGI and why does it matter for Bottle applications? Correct answer: WSGI is the standard interface between Python web applications and servers. Bottle is WSGI-compliant, meaning you can run it with any WSGI server (Gunicorn, uWSGI, etc.). Understanding WSGI is crucial for production deployment.
Code Challenge: Build a REST API with Bottle that manages a collection of items (CRUD operations). Requirements: GET /items (list), POST /items (create), GET /items/
Bottle developers in LatAm are relatively specialized (most Python developers prefer Flask or Django), so salaries reflect moderate scarcity:
US market comparison: Bottle developers in the US typically earn $80,000-$140,000, though the skill is less commonly hired. LatAm talent provides 40-60% cost savings while offering experienced Python expertise and REST API design knowledge.
What's included in all-in staffing rates: benefits, equipment, compliance, tax handling, and ongoing support. Direct hiring adds payroll administration overhead.
If you're building APIs or microservices where simplicity and minimal overhead matter, LatAm Bottle developers offer strategic advantages. The expertise pool is concentrated among senior Python developers who chose Bottle intentionally for specific architectural advantages. This means you're hiring experienced engineers who understand API design deeply.
Time zone overlap is significant: most LatAm developers work UTC-3 to UTC-5, providing 6-8 hours of real-time collaboration with US East Coast teams. This matters for API development where tight coordination between frontend and backend teams is valuable.
Cost efficiency is clear: you're hiring experienced Python developers at 40-60% of US rates. Bottle's minimalism appeals to lean, efficient engineering teams that value control and transparency. LatAm developers in this category often bring strong fundamentals in computer science and API design.
LatAm Bottle developers are often building APIs that integrate with larger systems or serve mobile applications. They understand API versioning, backward compatibility, and contract negotiation between services. This experience is valuable regardless of which framework you ultimately choose.
Start by clarifying your project: Are you building a REST API? Microservice? Internal tool? What's your scale and performance requirements? Do you have existing services written in Bottle, or are you considering it for a new project?
South matches you from our network of experienced Python developers with Bottle expertise. We assess API design understanding, HTTP knowledge, and ability to make framework choices consciously. We evaluate communication and how well they can document API contracts for frontend teams.
You'll interview 2-4 candidates in real-time. We manage vetting, but you make the hiring decision. Once selected, we handle contracts, payroll, compliance, equipment, and support. If a developer isn't working out, we provide replacement support within 30 days at no additional cost.
Ready to build lean APIs? Start with South today.
Yes. Bottle continues to be maintained by its community, though at a slower pace than more popular frameworks. Updates are backward-compatible and focused on stability rather than feature additions. The philosophy is: Bottle is feature-complete for its intended purpose.
Choose Bottle if you want maximum simplicity and minimal dependencies. Choose Flask if you want more ecosystem support, extensions, and community resources. For simple APIs, Bottle is excellent. For complex applications needing middleware, authentication, ORM integration, Flask is easier.
Bottle can handle large-scale systems, but you'll build many features manually that Flask and Django provide. Bottle works well for microservices architectures where each service is small and focused. For monolithic applications, Flask or Django are more practical.
Bottle doesn't include ORM support. Use SQLAlchemy, Peewee, or write raw SQL. This is intentional—Bottle stays minimal, and you choose your database layer. Many Bottle developers use SQLAlchemy for its flexibility and power.
Typically 7-14 business days. Bottle is less common than Flask or Django, so we work with a smaller pool of dedicated Bottle developers. Timeline depends more on your availability to interview than our sourcing speed.
Yes. South works with developers on full-time, part-time, and project-based arrangements. API projects often have clear milestones, making them suitable for part-time or contract work.
Most operate in UTC-3 to UTC-5, providing 6-8 hours of daily overlap with US East Coast hours and 3-5 hours with US West Coast hours.
We assess HTTP knowledge, REST API design understanding, and hands-on Bottle experience through technical interviews. We evaluate their ability to choose frameworks consciously and architect systems with minimal dependencies.
We provide replacement support within 30 days at no additional cost. If the developer isn't meeting expectations, we source and vet a replacement, no contracts or penalties.
Yes. South handles all payroll, tax compliance, benefits administration, and equipment for offshore developers. You manage the work relationship; we handle employment administration.
Yes. Bottle developers often work independently on focused services, but South can source multiple developers if you're building a larger system or microservices platform.
Python (core), SQLAlchemy, PostgreSQL, REST API design, Gunicorn/uWSGI (WSGI servers), Docker, and cloud deployment platforms. If you're building a full-stack system, pair Bottle backend developers with frontend developers.
