Google: Gemma 2 27B

Review this Python function for potential bugs. Focus on edge cases and type safety issues: def calculate_discount(price, discount_percent): return price - (price * discount_percent / 100)

The function has several issues: 1. **No input validation**: Negative prices or discount percentages above 100 could produce nonsensical results. A discount_percent of 150 would give a negative final price. 2. **Type assumptions**: The function assumes numeric inputs but doesn't enforce this. Passing strings would cause a TypeError. 3. **Floating-point precision**: For financial calculations, this could accumulate rounding errors. Consider using the `decimal` module for currency. 4. **Missing bounds check**: discount_percent should typically be clamped between 0-100. Recommended fix: Add type hints, validate inputs with `if discount_percent < 0 or discount_percent > 100: raise ValueError()`, and consider returning `Decimal` for monetary precision.

Gemma 2 27B excels at structured code review with practical recommendations. The 8K context window handles typical function-level analysis comfortably, though it may struggle with reviewing entire codebases or deeply nested call chains that exceed this limit.

Explain the CAP theorem to a junior developer who understands databases but hasn't worked with distributed systems. Use a real-world analogy.

Think of CAP like running a chain of coffee shops: **Consistency** means every location shows the same loyalty points balance instantly. If you earn points at one shop, all shops see it immediately. **Availability** means every shop can always process transactions, even if the network connecting them goes down. **Partition tolerance** means the system keeps working when shops can't communicate with each other. CAP theorem says you can only guarantee two of these three. Most distributed databases choose partition tolerance (networks fail) plus either consistency (banks, inventory) or availability (social media feeds, caches). You can't have all three because if shops can't talk to each other AND must stay available, they can't guarantee they're showing the same data.

The model produces clear technical explanations with appropriate analogies for the audience level specified. At $0.65 per million tokens for both input and output, it's cost-effective for documentation and educational content, though the 8K window may require chunking for long-form technical writing.

Generate a SQL query to find customers who made purchases in Q1 2024 but not in Q2 2024, including their total Q1 spend. Tables: customers(id, name), orders(id, customer_id, order_date, amount).

```sql SELECT c.id, c.name, SUM(o.amount) AS q1_total_spend FROM customers c INNER JOIN orders o ON c.id = o.customer_id WHERE o.order_date >= '2024-01-01' AND o.order_date < '2024-04-01' AND c.id NOT IN ( SELECT DISTINCT customer_id FROM orders WHERE order_date >= '2024-04-01' AND order_date < '2024-07-01' ) GROUP BY c.id, c.name ORDER BY q1_total_spend DESC; ``` This uses a subquery to exclude customers with Q2 orders, then aggregates Q1 spending for the remaining customers.

Gemma 2 27B generates syntactically correct SQL with appropriate joins and date filtering. The model handles multi-step logic well within its context window. For complex queries spanning dozens of tables or requiring extensive schema context, the 8K token limit becomes a constraint compared to larger-context alternatives.

When Gemma 2 27B fits small-team knowledge bases under budget

A 12-person SaaS startup needs an AI assistant that answers questions from their Notion wiki and Google Docs without burning through API credits. Gemma 2 27B hits the sweet spot here: at $0.65/Mtok both ways, you're looking at roughly $1.30 per million tokens round-trip, which means 500 employee queries averaging 400 tokens each costs about $0.26. The 8,192-token context window covers most internal docs when chunked properly, and the 27B parameter count handles technical jargon and multi-step reasoning better than smaller models. If your knowledge base regularly requires stitching together 15+ documents per answer, you'll hit the context ceiling and should consider a long-context alternative. Otherwise, this model keeps your documentation assistant running at predictable cost while your team stays under 2,000 queries per month.

Gemma 2 27B for overnight comment filtering at scale

A community platform with 80,000 daily comments needs to flag policy violations before moderators clock in at 9am. Gemma 2 27B works well in this batch-processing scenario because speed matters less than cost and accuracy. Running 80,000 comments at an average 150 tokens each (input) plus 50-token classification outputs gives you roughly 16M tokens total per day, or about $10.40 in API costs. The model's size handles nuanced policy edge cases—sarcasm, context-dependent slurs, coordinated harassment patterns—better than sub-20B alternatives, and the 8K context window lets you include the previous two comments for thread-aware decisions. If you need real-time moderation under 200ms, this won't work; for overnight batch jobs where you're optimizing cost per accurate flag, Gemma 2 27B delivers.

When Gemma 2 27B handles support volume without enterprise pricing

A 25-person e-commerce company processes 400 support emails daily and wants AI to draft responses for agents to review and send. Gemma 2 27B makes sense here because the context window accommodates a typical email thread (customer message plus order history snippet), and the $0.65/Mtok pricing keeps monthly costs under $200 even at peak volume. Assuming 600 input tokens per draft (email + context) and 300 output tokens per response, you're spending roughly $0.52 per day at 400 emails. The 27B parameter count produces replies that sound less robotic than 7B-class models, reducing the editing burden on your agents. If your email threads regularly exceed 6,000 tokens or you need sub-second latency for live chat, look elsewhere. For async email workflows where agents spend 30 seconds polishing each draft, this model cuts response time in half without the sticker shock of frontier models.