Senior Backend
- 2.4k installs
- 29.9k repo stars
- Updated July 27, 2026
- davila7/claude-code-templates
senior-backend is a toolkit skill with scripts and references for scalable API, database, and security backend development.
About
The senior-backend skill is a comprehensive backend toolkit covering API scaffolding, database migration analysis, load testing, and security reference guides for Node.js, Express, Go, Python, GraphQL, REST, and PostgreSQL stacks. Three Python scripts provide automated api scaffolder, database migration tool, and api load tester workflows with configurable templates and quality checks. Reference docs cover API design patterns, database optimization, and backend security practices with anti-patterns and troubleshooting sections. The documented tech stack spans TypeScript, JavaScript, Python, Go, React, Next.js, Prisma, NeonDB, Supabase, Docker, Kubernetes, Terraform, and major clouds. Development workflow guidance walks through dependency install, environment configuration, analyzer runs, and deployment commands. Best practices stress input validation, parameterized queries, authentication, caching, monitoring, and maintainable naming. Agents invoke it when designing APIs, optimizing queries, implementing auth, reviewing backend code, or running analysis scripts against a project path.
- Three scripts: api scaffolder, database migration tool, api load tester.
- Reference guides for API patterns, DB optimization, and security.
- Covers Node, Express, Go, Python, GraphQL, REST, and PostgreSQL.
- Workflow from setup, quality checks, best practices, to Docker deploy.
- Security emphasis: validate inputs, parameterized queries, and auth.
Senior Backend by the numbers
- 2,420 all-time installs (skills.sh)
- +25 installs in the week ending Jul 28, 2026 (Skillselion tracking)
- Ranked #213 of 4,386 Backend & APIs skills by installs in the Skillselion catalog
- Security screen: LOW risk (skills.sh audit)
- Data as of Jul 28, 2026 (Skillselion catalog sync)
senior-backend capabilities & compatibility
- Capabilities
- api scaffolder script with templates and quality · database migration analysis and recommendations · api load tester for performance validation · reference docs for patterns, optimization, and s · multi language stack coverage and deploy command
- Use cases
- api development · database · security audit
What senior-backend says it does
Complete toolkit for senior backend with modern tools and best practices.
python scripts/database_migration_tool.py <target-path> [--verbose]
npx skills add https://github.com/davila7/claude-code-templates --skill senior-backendAdd your badge
Show developers this skill is listed on Skillselion. Paste this into your README.
| Installs | 2.4k |
|---|---|
| repo stars | ★ 29.9k |
| Security audit | 3 / 3 scanners passed |
| Last updated | July 27, 2026 |
| Repository | davila7/claude-code-templates ↗ |
How do I scaffold APIs, optimize databases, and apply backend security patterns across a modern stack?
Scaffold APIs, run database migrations, load-test endpoints, and apply backend security patterns across Node, Go, Python, and Postgres stacks.
Who is it for?
Backend developers designing APIs, migrations, load tests, or reviewing server code quality.
Skip if: Skip for frontend-only UI work or mobile-specific App Store tasks without server components.
When should I use this skill?
User asks about api_scaffolder.py, database_migration_tool.py, backend security practices, or API load testing.
What you get
Runnable scaffolder or analyzer scripts plus reference-backed patterns for API, DB, and security work.
- API scaffold
- optimized SQL queries
- load-test output
By the numbers
- Provides three core capabilities through automated scripts
- Covers Node.js, Express, Go, Python, Postgres, GraphQL, and REST APIs
Files
Senior Backend
Complete toolkit for senior backend with modern tools and best practices.
Quick Start
Main Capabilities
This skill provides three core capabilities through automated scripts:
# Script 1: Api Scaffolder
python scripts/api_scaffolder.py [options]
# Script 2: Database Migration Tool
python scripts/database_migration_tool.py [options]
# Script 3: Api Load Tester
python scripts/api_load_tester.py [options]Core Capabilities
1. Api Scaffolder
Automated tool for api scaffolder tasks.
Features:
- Automated scaffolding
- Best practices built-in
- Configurable templates
- Quality checks
Usage:
python scripts/api_scaffolder.py <project-path> [options]2. Database Migration Tool
Comprehensive analysis and optimization tool.
Features:
- Deep analysis
- Performance metrics
- Recommendations
- Automated fixes
Usage:
python scripts/database_migration_tool.py <target-path> [--verbose]3. Api Load Tester
Advanced tooling for specialized tasks.
Features:
- Expert-level automation
- Custom configurations
- Integration ready
- Production-grade output
Usage:
python scripts/api_load_tester.py [arguments] [options]Reference Documentation
Api Design Patterns
Comprehensive guide available in references/api_design_patterns.md:
- Detailed patterns and practices
- Code examples
- Best practices
- Anti-patterns to avoid
- Real-world scenarios
Database Optimization Guide
Complete workflow documentation in references/database_optimization_guide.md:
- Step-by-step processes
- Optimization strategies
- Tool integrations
- Performance tuning
- Troubleshooting guide
Backend Security Practices
Technical reference guide in references/backend_security_practices.md:
- Technology stack details
- Configuration examples
- Integration patterns
- Security considerations
- Scalability guidelines
Tech Stack
Languages: TypeScript, JavaScript, Python, Go, Swift, Kotlin Frontend: React, Next.js, React Native, Flutter Backend: Node.js, Express, GraphQL, REST APIs Database: PostgreSQL, Prisma, NeonDB, Supabase DevOps: Docker, Kubernetes, Terraform, GitHub Actions, CircleCI Cloud: AWS, GCP, Azure
Development Workflow
1. Setup and Configuration
# Install dependencies
npm install
# or
pip install -r requirements.txt
# Configure environment
cp .env.example .env2. Run Quality Checks
# Use the analyzer script
python scripts/database_migration_tool.py .
# Review recommendations
# Apply fixes3. Implement Best Practices
Follow the patterns and practices documented in:
references/api_design_patterns.mdreferences/database_optimization_guide.mdreferences/backend_security_practices.md
Best Practices Summary
Code Quality
- Follow established patterns
- Write comprehensive tests
- Document decisions
- Review regularly
Performance
- Measure before optimizing
- Use appropriate caching
- Optimize critical paths
- Monitor in production
Security
- Validate all inputs
- Use parameterized queries
- Implement proper authentication
- Keep dependencies updated
Maintainability
- Write clear code
- Use consistent naming
- Add helpful comments
- Keep it simple
Common Commands
# Development
npm run dev
npm run build
npm run test
npm run lint
# Analysis
python scripts/database_migration_tool.py .
python scripts/api_load_tester.py --analyze
# Deployment
docker build -t app:latest .
docker-compose up -d
kubectl apply -f k8s/Troubleshooting
Common Issues
Check the comprehensive troubleshooting section in references/backend_security_practices.md.
Getting Help
- Review reference documentation
- Check script output messages
- Consult tech stack documentation
- Review error logs
Resources
- Pattern Reference:
references/api_design_patterns.md - Workflow Guide:
references/database_optimization_guide.md - Technical Guide:
references/backend_security_practices.md - Tool Scripts:
scripts/directory
Api Design Patterns
Overview
This reference guide provides comprehensive information for senior backend.
Patterns and Practices
Pattern 1: Best Practice Implementation
Description: Detailed explanation of the pattern.
When to Use:
- Scenario 1
- Scenario 2
- Scenario 3
Implementation:
// Example code implementation
export class Example {
// Implementation details
}Benefits:
- Benefit 1
- Benefit 2
- Benefit 3
Trade-offs:
- Consider 1
- Consider 2
- Consider 3
Pattern 2: Advanced Technique
Description: Another important pattern for senior backend.
Implementation:
// Advanced example
async function advancedExample() {
// Code here
}Guidelines
Code Organization
- Clear structure
- Logical separation
- Consistent naming
- Proper documentation
Performance Considerations
- Optimization strategies
- Bottleneck identification
- Monitoring approaches
- Scaling techniques
Security Best Practices
- Input validation
- Authentication
- Authorization
- Data protection
Common Patterns
Pattern A
Implementation details and examples.
Pattern B
Implementation details and examples.
Pattern C
Implementation details and examples.
Anti-Patterns to Avoid
Anti-Pattern 1
What not to do and why.
Anti-Pattern 2
What not to do and why.
Tools and Resources
Recommended Tools
- Tool 1: Purpose
- Tool 2: Purpose
- Tool 3: Purpose
Further Reading
- Resource 1
- Resource 2
- Resource 3
Conclusion
Key takeaways for using this reference guide effectively.
Backend Security Practices
Overview
This reference guide provides comprehensive information for senior backend.
Patterns and Practices
Pattern 1: Best Practice Implementation
Description: Detailed explanation of the pattern.
When to Use:
- Scenario 1
- Scenario 2
- Scenario 3
Implementation:
// Example code implementation
export class Example {
// Implementation details
}Benefits:
- Benefit 1
- Benefit 2
- Benefit 3
Trade-offs:
- Consider 1
- Consider 2
- Consider 3
Pattern 2: Advanced Technique
Description: Another important pattern for senior backend.
Implementation:
// Advanced example
async function advancedExample() {
// Code here
}Guidelines
Code Organization
- Clear structure
- Logical separation
- Consistent naming
- Proper documentation
Performance Considerations
- Optimization strategies
- Bottleneck identification
- Monitoring approaches
- Scaling techniques
Security Best Practices
- Input validation
- Authentication
- Authorization
- Data protection
Common Patterns
Pattern A
Implementation details and examples.
Pattern B
Implementation details and examples.
Pattern C
Implementation details and examples.
Anti-Patterns to Avoid
Anti-Pattern 1
What not to do and why.
Anti-Pattern 2
What not to do and why.
Tools and Resources
Recommended Tools
- Tool 1: Purpose
- Tool 2: Purpose
- Tool 3: Purpose
Further Reading
- Resource 1
- Resource 2
- Resource 3
Conclusion
Key takeaways for using this reference guide effectively.
Database Optimization Guide
Overview
This reference guide provides comprehensive information for senior backend.
Patterns and Practices
Pattern 1: Best Practice Implementation
Description: Detailed explanation of the pattern.
When to Use:
- Scenario 1
- Scenario 2
- Scenario 3
Implementation:
// Example code implementation
export class Example {
// Implementation details
}Benefits:
- Benefit 1
- Benefit 2
- Benefit 3
Trade-offs:
- Consider 1
- Consider 2
- Consider 3
Pattern 2: Advanced Technique
Description: Another important pattern for senior backend.
Implementation:
// Advanced example
async function advancedExample() {
// Code here
}Guidelines
Code Organization
- Clear structure
- Logical separation
- Consistent naming
- Proper documentation
Performance Considerations
- Optimization strategies
- Bottleneck identification
- Monitoring approaches
- Scaling techniques
Security Best Practices
- Input validation
- Authentication
- Authorization
- Data protection
Common Patterns
Pattern A
Implementation details and examples.
Pattern B
Implementation details and examples.
Pattern C
Implementation details and examples.
Anti-Patterns to Avoid
Anti-Pattern 1
What not to do and why.
Anti-Pattern 2
What not to do and why.
Tools and Resources
Recommended Tools
- Tool 1: Purpose
- Tool 2: Purpose
- Tool 3: Purpose
Further Reading
- Resource 1
- Resource 2
- Resource 3
Conclusion
Key takeaways for using this reference guide effectively.
#!/usr/bin/env python3
"""
Api Load Tester
Automated tool for senior backend tasks
"""
import os
import sys
import json
import argparse
from pathlib import Path
from typing import Dict, List, Optional
class ApiLoadTester:
"""Main class for api load tester functionality"""
def __init__(self, target_path: str, verbose: bool = False):
self.target_path = Path(target_path)
self.verbose = verbose
self.results = {}
def run(self) -> Dict:
"""Execute the main functionality"""
print(f"🚀 Running {self.__class__.__name__}...")
print(f"📁 Target: {self.target_path}")
try:
self.validate_target()
self.analyze()
self.generate_report()
print("✅ Completed successfully!")
return self.results
except Exception as e:
print(f"❌ Error: {e}")
sys.exit(1)
def validate_target(self):
"""Validate the target path exists and is accessible"""
if not self.target_path.exists():
raise ValueError(f"Target path does not exist: {self.target_path}")
if self.verbose:
print(f"✓ Target validated: {self.target_path}")
def analyze(self):
"""Perform the main analysis or operation"""
if self.verbose:
print("📊 Analyzing...")
# Main logic here
self.results['status'] = 'success'
self.results['target'] = str(self.target_path)
self.results['findings'] = []
# Add analysis results
if self.verbose:
print(f"✓ Analysis complete: {len(self.results.get('findings', []))} findings")
def generate_report(self):
"""Generate and display the report"""
print("\n" + "="*50)
print("REPORT")
print("="*50)
print(f"Target: {self.results.get('target')}")
print(f"Status: {self.results.get('status')}")
print(f"Findings: {len(self.results.get('findings', []))}")
print("="*50 + "\n")
def main():
"""Main entry point"""
parser = argparse.ArgumentParser(
description="Api Load Tester"
)
parser.add_argument(
'target',
help='Target path to analyze or process'
)
parser.add_argument(
'--verbose', '-v',
action='store_true',
help='Enable verbose output'
)
parser.add_argument(
'--json',
action='store_true',
help='Output results as JSON'
)
parser.add_argument(
'--output', '-o',
help='Output file path'
)
args = parser.parse_args()
tool = ApiLoadTester(
args.target,
verbose=args.verbose
)
results = tool.run()
if args.json:
output = json.dumps(results, indent=2)
if args.output:
with open(args.output, 'w') as f:
f.write(output)
print(f"Results written to {args.output}")
else:
print(output)
if __name__ == '__main__':
main()
#!/usr/bin/env python3
"""
Api Scaffolder
Automated tool for senior backend tasks
"""
import os
import sys
import json
import argparse
from pathlib import Path
from typing import Dict, List, Optional
class ApiScaffolder:
"""Main class for api scaffolder functionality"""
def __init__(self, target_path: str, verbose: bool = False):
self.target_path = Path(target_path)
self.verbose = verbose
self.results = {}
def run(self) -> Dict:
"""Execute the main functionality"""
print(f"🚀 Running {self.__class__.__name__}...")
print(f"📁 Target: {self.target_path}")
try:
self.validate_target()
self.analyze()
self.generate_report()
print("✅ Completed successfully!")
return self.results
except Exception as e:
print(f"❌ Error: {e}")
sys.exit(1)
def validate_target(self):
"""Validate the target path exists and is accessible"""
if not self.target_path.exists():
raise ValueError(f"Target path does not exist: {self.target_path}")
if self.verbose:
print(f"✓ Target validated: {self.target_path}")
def analyze(self):
"""Perform the main analysis or operation"""
if self.verbose:
print("📊 Analyzing...")
# Main logic here
self.results['status'] = 'success'
self.results['target'] = str(self.target_path)
self.results['findings'] = []
# Add analysis results
if self.verbose:
print(f"✓ Analysis complete: {len(self.results.get('findings', []))} findings")
def generate_report(self):
"""Generate and display the report"""
print("\n" + "="*50)
print("REPORT")
print("="*50)
print(f"Target: {self.results.get('target')}")
print(f"Status: {self.results.get('status')}")
print(f"Findings: {len(self.results.get('findings', []))}")
print("="*50 + "\n")
def main():
"""Main entry point"""
parser = argparse.ArgumentParser(
description="Api Scaffolder"
)
parser.add_argument(
'target',
help='Target path to analyze or process'
)
parser.add_argument(
'--verbose', '-v',
action='store_true',
help='Enable verbose output'
)
parser.add_argument(
'--json',
action='store_true',
help='Output results as JSON'
)
parser.add_argument(
'--output', '-o',
help='Output file path'
)
args = parser.parse_args()
tool = ApiScaffolder(
args.target,
verbose=args.verbose
)
results = tool.run()
if args.json:
output = json.dumps(results, indent=2)
if args.output:
with open(args.output, 'w') as f:
f.write(output)
print(f"Results written to {args.output}")
else:
print(output)
if __name__ == '__main__':
main()
#!/usr/bin/env python3
"""
Database Migration Tool
Automated tool for senior backend tasks
"""
import os
import sys
import json
import argparse
from pathlib import Path
from typing import Dict, List, Optional
class DatabaseMigrationTool:
"""Main class for database migration tool functionality"""
def __init__(self, target_path: str, verbose: bool = False):
self.target_path = Path(target_path)
self.verbose = verbose
self.results = {}
def run(self) -> Dict:
"""Execute the main functionality"""
print(f"🚀 Running {self.__class__.__name__}...")
print(f"📁 Target: {self.target_path}")
try:
self.validate_target()
self.analyze()
self.generate_report()
print("✅ Completed successfully!")
return self.results
except Exception as e:
print(f"❌ Error: {e}")
sys.exit(1)
def validate_target(self):
"""Validate the target path exists and is accessible"""
if not self.target_path.exists():
raise ValueError(f"Target path does not exist: {self.target_path}")
if self.verbose:
print(f"✓ Target validated: {self.target_path}")
def analyze(self):
"""Perform the main analysis or operation"""
if self.verbose:
print("📊 Analyzing...")
# Main logic here
self.results['status'] = 'success'
self.results['target'] = str(self.target_path)
self.results['findings'] = []
# Add analysis results
if self.verbose:
print(f"✓ Analysis complete: {len(self.results.get('findings', []))} findings")
def generate_report(self):
"""Generate and display the report"""
print("\n" + "="*50)
print("REPORT")
print("="*50)
print(f"Target: {self.results.get('target')}")
print(f"Status: {self.results.get('status')}")
print(f"Findings: {len(self.results.get('findings', []))}")
print("="*50 + "\n")
def main():
"""Main entry point"""
parser = argparse.ArgumentParser(
description="Database Migration Tool"
)
parser.add_argument(
'target',
help='Target path to analyze or process'
)
parser.add_argument(
'--verbose', '-v',
action='store_true',
help='Enable verbose output'
)
parser.add_argument(
'--json',
action='store_true',
help='Output results as JSON'
)
parser.add_argument(
'--output', '-o',
help='Output file path'
)
args = parser.parse_args()
tool = DatabaseMigrationTool(
args.target,
verbose=args.verbose
)
results = tool.run()
if args.json:
output = json.dumps(results, indent=2)
if args.output:
with open(args.output, 'w') as f:
f.write(output)
print(f"Results written to {args.output}")
else:
print(output)
if __name__ == '__main__':
main()
Related skills
Lark Openapi ExplorerInstantly explore, test, and generate calls against the full Lark (Feishu) OpenAPI surface without leaving their agent workflow.471k
Lark EventConsume real-time events from Lark/Feishu as structured NDJSON streams inside AI agent workflows.382k15.8kLark Openapi ExplorerWhen an existing Lark/Feishu skill or CLI command cannot fulfill a specific requirement and they need to discover and invoke the exact native OpenAPI endpoint.381k15.8k
Just ScrapeQuickly search, crawl, extract structured JSON, or monitor web pages without writing custom scraping code.245k37Lark AppsQuery the current visibility and permission scope of a Lark (Feishu) app without writing HTTP client code.230k15.8k
SupabaseGet accurate, up-to-date Supabase implementation guidance across database, auth, realtime, storage, edge functions and vector search without relying on outd182k2.4kForks & variants (1)
Senior Backend has 1 known copy in the catalog totaling 52 installs. They canonicalize to this original listing.
- ovachiever - 52 installs
How it compares
Use senior-backend over narrow framework skills when the task spans API scaffolding, Postgres optimization, and load testing across multiple backend stacks.
FAQ
What scripts does the skill provide?
api_scaffolder.py, database_migration_tool.py, and api_load_tester.py with documented CLI usage.
Which databases are covered?
PostgreSQL with Prisma, NeonDB, and Supabase called out in the tech stack and optimization guide.
Where are design patterns documented?
In references/api_design_patterns.md, database_optimization_guide.md, and backend_security_practices.md.
Is Senior Backend safe to install?
skills.sh reports 3 of 3 security scanners passed. Review the Security Audits panel on this page before installing in production.