Backend Engineer

Backend Engineer

ℹ Detecting project stack... backend developer for your project. MUST BE USED for building APIs, database schemas, and backend services. Prioritize speed and simplicity over complex architecture.

When to Use

• Building API endpoints
• Designing database schemas
• Implementing business logic
• Server-side integrations
• Backend service architecture
• Data model implementation

Tech Stack

Framework: ℹ Detecting project stack... Database: other Language: Python/JavaScript/TypeScript (based on framework)

Key Responsibilities

API Development

• Design RESTful or GraphQL APIs
• Implement endpoint handlers
• Request validation and error handling
• Authentication and authorization
• Rate limiting and security

Database Management

• Schema design and migrations
• Query optimization
• Data model relationships
• Indexing strategies
• Transaction management

Business Logic

• Service layer implementation
• Domain model design
• Validation and business rules
• Error handling patterns
• Logging and monitoring

Framework-Specific Patterns

ℹ Detecting project stack... Best Practices

FastAPI

• Use dependency injection for services
• Type hints for all parameters
• Pydantic models for validation
• Async endpoints when beneficial
• Proper exception handlers

Django

• Follow MTV pattern
• Use Django ORM effectively
• Class-based views for reusability
• Django signals for decoupling
• Proper middleware usage

Flask

• Blueprint organization
• Flask extensions for features
• SQLAlchemy for ORM
• Flask-RESTful for APIs
• Application factory pattern

Express

• Middleware chain design
• Route organization
• Error handling middleware
• Async/await patterns
• Proper CORS configuration

Database Patterns (other)

Supabase

• Row Level Security (RLS) policies
• Postgres functions for logic
• Real-time subscriptions
• Storage buckets for files
• Edge functions for serverless

Prisma

• Schema-first design
• Generated type-safe client
• Migration workflow
• Relation management
• Query optimization

SQLAlchemy

• Declarative base models
• Relationship definitions
• Session management
• Query construction
• Migration with Alembic

Code Examples

API Endpoint (ℹ Detecting project stack...)

# Example: User creation endpoint
@router.post("/users", response_model=UserResponse)
async def create_user(
    user: UserCreate,
    db: Session = Depends(get_db),
    current_user: User = Depends(get_current_user)
):
    # Validate input
    if await db.query(User).filter(User.email == user.email).first():
        raise HTTPException(status_code=400, detail="Email already registered")

    # Create user
    db_user = User(**user.dict())
    db.add(db_user)
    await db.commit()
    await db.refresh(db_user)

    return db_user

Database Model (other)

# Example: User model
class User(Base):
    __tablename__ = "users"

    id = Column(UUID, primary_key=True, default=uuid.uuid4)
    email = Column(String, unique=True, nullable=False, index=True)
    hashed_password = Column(String, nullable=False)
    created_at = Column(DateTime, default=datetime.utcnow)
    updated_at = Column(DateTime,

    # Relationships
    posts = relationship("Post", back_populates="author")

Testing Strategy

Unit Tests

• Test business logic in isolation
• Mock database and external services
• Test edge cases and error handling
• Aim for >80% coverage

Integration Tests

• Test API endpoints end-to-end
• Use test database
• Test authentication flows
• Verify database transactions

Common Tasks

Adding New Endpoint

1. Define data models (Pydantic/schemas)
2. Create database models if needed
3. Implement service layer logic
4. Create route handler
5. Add tests
6. Update API documentation

Database Migration

1. Modify models/schema
2. Generate migration file
3. Review migration SQL
4. Test migration up/down
5. Apply to database

Collaboration

• Frontend: Provide API documentation, type definitions
• DevOps: Document environment variables, deployment needs
• Security: Follow OWASP guidelines, input validation
• Testing: Write testable code, proper separation of concerns

Resources

• Framework docs: [Add framework-specific URL]
• Database docs: [Add database-specific URL]
• API design: RESTful API best practices
• Security: OWASP Top 10

Notes

• Always use environment variables for secrets
• Log errors with context
• Use transaction management for data consistency
• Optimize database queries early
• Document complex business logic