Next Steps

You’ve completed the Getting Started guide. You now know how to install Rivaas, build applications, configure them, and add middleware.

What You’ve Learned

✅ Installation — Set up Rivaas and verified it works
✅ First Application — Built a REST API with routes and JSON responses
✅ Configuration — Configured service metadata, health checks, and observability
✅ Middleware — Added functionality like CORS and authentication

Choose Your Path

🚀 Building Production APIs

Learn advanced routing, error handling, and API patterns:

• Routing Guide — Advanced routing patterns, groups, and constraints
• Request Binding — Bind and validate JSON, XML, YAML, and form data
• OpenAPI Documentation — Auto-generate API specs
• Validation Guide — Input validation strategies

Recommended Example: Blog API — Full-featured blog with CRUD operations, validation, and testing.

📊 Observability & Monitoring

Understand your application in production:

• Logging Guide — Structured logging with slog
• Metrics Guide — Prometheus metrics and custom instrumentation
• Tracing Guide — Distributed tracing with OpenTelemetry
• Health Endpoints — Kubernetes-compatible liveness/readiness

Key Pattern: The observability trinity (logs, metrics, traces) works together. They provide complete visibility into your application.

🔒 Security & Best Practices

Secure your APIs:

• Validation Guide — Input validation and sanitization
• Validation Security — Security considerations for validation
• Router Middleware — Security middleware (basic auth, rate limiting)

Security Checklist:

• ✅ Use HTTPS in production
• ✅ Validate all inputs
• ✅ Implement authentication
• ✅ Add rate limiting
• ✅ Enable security headers

☁️ Deployment & Operations

Deploy your application to production:

• App Configuration — Environment-based config
• Server Configuration — Timeouts and graceful shutdown
• Health Endpoints — Kubernetes-compatible probes
• Debug Endpoints — pprof for profiling

Production Checklist:

• ✅ Set up health endpoints
• ✅ Configure timeouts
• ✅ Enable observability
• ✅ Use environment variables
• ✅ Implement graceful shutdown

🎯 Advanced Topics

Deep dive into framework internals:

• Router Middleware — Build reusable middleware
• App Testing — Unit, integration, and E2E tests
• Lifecycle Hooks — Application lifecycle management

Example Applications

Learn from complete, production-ready examples:

Quick Start Example

Path: /app/examples/01-quick-start
Complexity: Beginner
Shows: Minimal setup, basic routing, health checks

cd app/examples/01-quick-start
go run main.go

Blog API Example

Path: /app/examples/02-blog
Complexity: Intermediate
Shows: CRUD operations, validation, OpenAPI, testing, configuration

cd app/examples/02-blog
go run main.go
# Visit http://localhost:8080/docs for Swagger UI

Features:

• Complete REST API (posts, authors, comments)
• Method-based validation
• OpenAPI documentation
• Comprehensive tests
• Configuration management
• Observability setup

More Examples

• Middleware Examples — All 12 middleware with curl commands
• Router Examples — Low-level router usage

Framework Packages

Rivaas is modular — use any package independently:

Core Packages

Data Handling

Observability

API & Errors

Learn More: Package Documentation

Reference Documentation

Quick access to API references:

• App Options — All configuration options
• App Context API — Request/response handling
• Router Middleware — All middleware options
• Router API — Low-level router API

Community & Support

Get Help

• 💬 GitHub Discussions — Ask questions, share ideas
• 🐛 GitHub Issues — Report bugs, request features
• 📧 Email — security@rivaas.dev (security issues only)

Contribute

Rivaas is open source and welcomes contributions:

• Contributing Guide — How to contribute
• Design Principles — Framework philosophy
• Testing Standards — Testing guidelines

Stay Updated

• ⭐ Star on GitHub — Get notified of releases
• 📦 Release Notes — What’s new
• 🗺️ Roadmap — Upcoming features

Quick Reference Card

Create Application

a, err := app.New(
    app.WithServiceName("my-api"),
    app.WithServiceVersion("v1.0.0"),
)

Register Routes

a.GET("/path", handler)
a.POST("/path", handler)
a.PUT("/path/:id", handler)
a.DELETE("/path/:id", handler)

Add Middleware

a.Use(middleware1, middleware2)
api := a.Group("/api", authMiddleware)

Start Server

ctx, cancel := signal.NotifyContext(context.Background(), os.Interrupt, syscall.SIGTERM)
defer cancel()
a.Start(ctx)

Handle Requests

func handler(c *app.Context) {
    // Get path parameter
    id := c.Param("id")
    
    // Get query parameter
    filter := c.Query("filter")
    
    // Bind request body (auto-detects JSON, form, etc.)
    var req MyRequest
    if err := c.Bind(&req); err != nil {
        c.JSON(400, map[string]string{"error": "Invalid request"})
        return
    }
    
    // Send JSON response
    c.JSON(200, map[string]string{"status": "ok"})
}

What’s Next?

Pick the topic that interests you most. The documentation works for both linear reading and jumping to specific topics.

Happy building with Rivaas!