$ cat /posts/what-is-supabase-architecture-and-core-features-explained.md

What is Supabase? Architecture and Core Features Explained

drwxr-xr-x2026-01-255 min0 views

Supabase is an open-source Backend-as-a-Service (BaaS) platform that provides developers with a complete backend infrastructure including PostgreSQL database, authentication, real-time subscriptions, file storage, and serverless functions—all integrated through a unified API and dashboard. Unlike proprietary solutions, Supabase is built on battle-tested open-source technologies making it transparent, customizable, and free from vendor lock-in while maintaining enterprise-grade performance and reliability. This comprehensive guide explains Supabase architecture, core components, how they work together, and why this design makes it the leading Firebase alternative for modern application development. Understanding Supabase's technical foundation enables you to build scalable, secure applications that leverage PostgreSQL's power combined with modern real-time features and serverless capabilities. If you're new to Supabase, start with our complete beginner's guide before diving into architecture details.

What is Supabase?

Supabase positions itself as "The Open Source Firebase Alternative" and delivers on this promise by providing all the backend services modern applications need without the complexity of managing servers or infrastructure. Founded in 2020 by Paul Copplestone and Ant Wilson, Supabase has grown rapidly to serve over 1 million developers and power thousands of production applications ranging from startups to enterprise companies. The platform's core philosophy centers on using proven open-source technologies rather than reinventing the wheel—PostgreSQL for database, GoTrue for authentication, PostgREST for auto-generated APIs, and custom-built Realtime server for live updates.

What sets Supabase apart is its commitment to open source (MIT license), SQL-first approach with full PostgreSQL capabilities, and developer experience that rivals proprietary solutions while maintaining transparency and flexibility. Every Supabase project runs on dedicated infrastructure with isolated databases ensuring security and performance, while the unified dashboard provides visual tools for managing data, writing queries, configuring authentication, and monitoring performance—all without leaving your browser. Learn how Supabase compares to Firebase in our detailed comparison guide.

Supabase Architecture Overview

Supabase architecture consists of multiple open-source components working together to provide a cohesive backend platform. Each component serves a specific purpose and can be used independently or together, giving developers flexibility in how they build applications:

Component	Technology	Purpose	Open Source License
Database	PostgreSQL 15	Primary data storage with full SQL support	PostgreSQL License
Auto API	PostgREST	RESTful API auto-generated from database schema	MIT
Authentication	GoTrue	User management and JWT token generation	MIT
Realtime	Realtime (Supabase)	WebSocket server for live database changes	Apache 2.0
Storage	Storage API	S3-compatible object storage for files	Apache 2.0
Edge Functions	Deno Deploy	Serverless TypeScript/JavaScript functions	MIT
Dashboard	Supabase Studio	Web-based admin interface	Apache 2.0

These components communicate through well-defined APIs creating a unified system. Your application connects to Supabase through the JavaScript client library (or Python, Dart, etc.) which handles authentication tokens, request routing, and error handling automatically. Requests flow through Kong API Gateway for routing and rate limiting, then to the appropriate service—PostgREST for database queries, GoTrue for authentication, Storage API for files, or Realtime for subscriptions.

PostgreSQL Database Foundation

At the heart of Supabase lies PostgreSQL, one of the most advanced open-source relational database systems with over 35 years of active development. Each Supabase project gets a dedicated PostgreSQL 15 instance with full superuser access, meaning you can use any PostgreSQL feature including stored procedures, triggers, views, materialized views, custom data types, extensions, and advanced indexing strategies. This is fundamentally different from Firebase's NoSQL Firestore which limits you to document-based storage without SQL capabilities. Learn PostgreSQL basics and table creation in our dedicated guide.

PostgreSQL provides ACID compliance (Atomicity, Consistency, Isolation, Durability) ensuring data integrity even during concurrent operations, complex transactions, or system failures. It supports advanced data types including JSON/JSONB for flexible schemas, arrays, geometric types, full-text search vectors, and custom types. Built-in features like foreign keys enforce referential integrity, check constraints validate data, and row-level security (RLS) provides fine-grained access control at the database level—far more secure than application-level permissions.

Full SQL Support: Write complex queries with JOINs, subqueries, CTEs (Common Table Expressions), window functions, and aggregations for sophisticated data analysis
Extensions Ecosystem: Enable pgvector for AI embeddings, pg_cron for scheduled tasks, PostGIS for geographic data, and dozens of other extensions expanding functionality
Performance Optimization: Create indexes (B-tree, Hash, GiST, GIN) for fast queries, use EXPLAIN for query analysis, and leverage PostgreSQL's sophisticated query planner
Data Integrity: Foreign key constraints maintain relationships, unique constraints prevent duplicates, check constraints validate data, and NOT NULL constraints ensure completeness
Advanced Features: Stored procedures for reusable logic, triggers for automatic actions, views for query abstraction, and materialized views for pre-computed results

PostgREST: Auto-Generated REST API

PostgREST is the magic that transforms your PostgreSQL database into a RESTful API automatically. Every table, view, and function in your database becomes instantly accessible through HTTP endpoints without writing a single line of backend code. When you create a 'users' table, PostgREST immediately exposes GET, POST, PATCH, and DELETE endpoints for that table with intelligent query parsing, filtering, and joining capabilities. This eliminates the traditional backend layer you'd build with Express, Django, or Rails for basic CRUD operations. Explore database queries to master API interactions.

PostgREST respects PostgreSQL's Row Level Security policies, meaning your API automatically enforces the same security rules defined in your database. It supports advanced query features like selecting specific columns, filtering with multiple conditions, ordering results, limiting for pagination, and even joining related tables—all through URL parameters. This declarative approach reduces code, eliminates common API bugs, and ensures your API stays in sync with your database schema automatically.

javascriptpostgrest_api_examples.js

// PostgREST automatically creates these endpoints from your database schema

// SELECT * FROM todos
GET /rest/v1/todos

// SELECT id, task, is_complete FROM todos WHERE user_id = 123
GET /rest/v1/todos?select=id,task,is_complete&user_id=eq.123

// SELECT * FROM todos WHERE is_complete = false ORDER BY created_at DESC
GET /rest/v1/todos?is_complete=eq.false&order=created_at.desc

// INSERT INTO todos (task, user_id) VALUES ('Learn Supabase', 123)
POST /rest/v1/todos
Body: {"task": "Learn Supabase", "user_id": 123}

// UPDATE todos SET is_complete = true WHERE id = 456
PATCH /rest/v1/todos?id=eq.456
Body: {"is_complete": true}

// DELETE FROM todos WHERE id = 456
DELETE /rest/v1/todos?id=eq.456

// JOIN query: SELECT todos.*, users.name FROM todos INNER JOIN users
GET /rest/v1/todos?select=*,users(name)

// Call stored function
POST /rest/v1/rpc/calculate_stats
Body: {"user_id": 123}

// The Supabase JavaScript client wraps these HTTP calls:
const { data } = await supabase
  .from('todos')
  .select('id, task, is_complete')
  .eq('user_id', userId)
  .order('created_at', { ascending: false })

GoTrue Authentication System

GoTrue handles all authentication and user management for Supabase projects. It supports multiple authentication methods including email/password with confirmation, magic links for passwordless authentication, phone authentication with SMS, and OAuth integration with Google, GitHub, Discord, and 20+ other providers. GoTrue issues JWT (JSON Web Tokens) that your application uses to identify users and that PostgreSQL RLS policies use to enforce data access rules. Learn complete authentication implementation in our dedicated guide.

The authentication system integrates seamlessly with the database through the special auth.users table which stores user accounts, and user metadata can be extended with custom fields. GoTrue handles complex workflows like email verification, password reset, email change confirmation, and token refresh automatically. It supports session management with customizable token expiration, refresh token rotation for security, and device management for tracking user sessions across multiple devices.

Email/Password Authentication: Traditional sign up with email verification, secure password hashing with bcrypt, and password reset flows. See email authentication guide
Magic Links: Passwordless authentication sending one-time login links via email for improved UX. Explore magic links implementation
OAuth Social Login: Integration with Google, GitHub, Facebook, Discord, and more for seamless social authentication. Learn OAuth setup
JWT Tokens: Secure authentication tokens with configurable expiration, automatic refresh, and integration with Row Level Security policies
User Management: Built-in user profiles, custom metadata fields, user sessions tracking, and admin API for user administration
Security Features: Rate limiting to prevent brute force attacks, email confirmation for verified accounts, CAPTCHA integration, and secure password policies

javascriptgotrue_auth_examples.js

// GoTrue Authentication Examples

// Sign up with email/password
const { data, error } = await supabase.auth.signUp({
  email: '[email protected]',
  password: 'secure-password-123',
  options: {
    data: {
      first_name: 'John',
      age: 27
    }
  }
})

// Sign in and get JWT token
const { data, error } = await supabase.auth.signInWithPassword({
  email: '[email protected]',
  password: 'secure-password-123'
})

console.log(data.session.access_token) // JWT token
console.log(data.user.id) // User ID

// OAuth sign in (Google)
const { data, error } = await supabase.auth.signInWithOAuth({
  provider: 'google'
})

// Magic link authentication
const { error } = await supabase.auth.signInWithOtp({
  email: '[email protected]'
})

// Get current user
const { data: { user } } = await supabase.auth.getUser()

// Sign out
await supabase.auth.signOut()

// Listen to auth state changes
supabase.auth.onAuthStateChange((event, session) => {
  console.log(event, session)
  // Events: SIGNED_IN, SIGNED_OUT, TOKEN_REFRESHED, USER_UPDATED
})

Realtime Server for Live Updates

Supabase Realtime is a custom-built Elixir server that provides WebSocket connections for live data synchronization. It listens to PostgreSQL's Write-Ahead Log (WAL) using logical replication to detect database changes and broadcasts them to connected clients in real-time. This enables building live features like chat applications, collaborative editing tools, live dashboards, multiplayer games, and notification systems without polling or complex backend infrastructure. Master real-time subscriptions to build live applications.

The Realtime server supports three types of channels: Postgres Changes for database subscriptions receiving INSERT, UPDATE, DELETE events; Presence for tracking which users are online in real-time; and Broadcast for sending messages between clients without database persistence. All subscriptions respect Row Level Security policies, ensuring users only receive updates for data they're authorized to access—critical for multi-tenant applications and privacy compliance.

Feature	Description	Use Cases	RLS Support
Postgres Changes	Listen to database INSERT, UPDATE, DELETE events	Live data feeds, notifications, sync	Yes
Presence	Track online users and their state in real-time	Online indicators, user locations, cursors	Yes
Broadcast	Send ephemeral messages between clients	Cursor positions, typing indicators, actions	Yes
Scalability	Horizontal scaling with connection pooling	Thousands of concurrent connections	N/A

javascriptrealtime_examples.js

// Realtime Database Subscriptions

// Subscribe to all changes on 'messages' table
const channel = supabase
  .channel('messages-channel')
  .on(
    'postgres_changes',
    { event: '*', schema: 'public', table: 'messages' },
    (payload) => {
      console.log('Change received!', payload)
      // payload.eventType: 'INSERT' | 'UPDATE' | 'DELETE'
      // payload.new: New row data
      // payload.old: Old row data (for UPDATE/DELETE)
    }
  )
  .subscribe()

// Subscribe only to INSERT events
const insertChannel = supabase
  .channel('new-messages')
  .on(
    'postgres_changes',
    { event: 'INSERT', schema: 'public', table: 'messages' },
    (payload) => {
      addMessageToUI(payload.new)
    }
  )
  .subscribe()

// Presence: Track online users
const presenceChannel = supabase.channel('room-1')

presenceChannel
  .on('presence', { event: 'sync' }, () => {
    const state = presenceChannel.presenceState()
    console.log('Online users:', state)
  })
  .on('presence', { event: 'join' }, ({ key, newPresences }) => {
    console.log('User joined:', newPresences)
  })
  .on('presence', { event: 'leave' }, ({ key, leftPresences }) => {
    console.log('User left:', leftPresences)
  })
  .subscribe(async (status) => {
    if (status === 'SUBSCRIBED') {
      await presenceChannel.track({ 
        user: 'John',
        online_at: new Date().toISOString() 
      })
    }
  })

// Broadcast: Send messages to other clients
const broadcastChannel = supabase.channel('cursor-positions')

broadcastChannel
  .on('broadcast', { event: 'cursor' }, (payload) => {
    console.log('Cursor moved:', payload)
  })
  .subscribe()

// Send broadcast message
await broadcastChannel.send({
  type: 'broadcast',
  event: 'cursor',
  payload: { x: 100, y: 200, user: 'John' }
})

// Cleanup
supabase.removeChannel(channel)

Storage API for File Management

Supabase Storage provides S3-compatible object storage for managing files like images, videos, documents, and any binary data. It includes built-in CDN for fast global delivery, automatic image transformations for resizing and optimization, resumable uploads for large files, and Row Level Security policies for fine-grained access control. Files are organized into buckets (similar to S3 buckets) which can be public or private, with each bucket supporting custom security policies. Learn complete storage implementation and React image upload patterns.

Storage integrates with authentication allowing user-specific file access rules, quota management, and tracking file ownership. The CDN automatically caches files globally for fast access regardless of user location, and on-the-fly image transformations enable serving optimized images without pre-processing—specify width, height, quality, format, and resize mode in the URL. Storage supports parallel uploads for better performance, progress tracking for user feedback, and automatic MIME type detection for proper content serving.

javascriptstorage_examples.js

// Supabase Storage Examples

// Upload a file
const file = event.target.files[0]
const fileName = `${Date.now()}-${file.name}`

const { data, error } = await supabase.storage
  .from('avatars')
  .upload(`public/${fileName}`, file, {
    cacheControl: '3600',
    upsert: false
  })

if (data) {
  console.log('Uploaded to:', data.path)
}

// Get public URL
const { data: publicURL } = supabase.storage
  .from('avatars')
  .getPublicUrl(`public/${fileName}`)

console.log('Access at:', publicURL.publicUrl)

// Image transformation (CDN)
const { data: transformedURL } = supabase.storage
  .from('avatars')
  .getPublicUrl(`public/${fileName}`, {
    transform: {
      width: 400,
      height: 400,
      resize: 'cover',
      quality: 80
    }
  })

// Download a file
const { data: blob, error } = await supabase.storage
  .from('avatars')
  .download(`public/${fileName}`)

if (blob) {
  const url = URL.createObjectURL(blob)
  // Use for display
}

// List files
const { data: files, error } = await supabase.storage
  .from('avatars')
  .list('public', {
    limit: 100,
    offset: 0,
    sortBy: { column: 'name', order: 'asc' }
  })

// Delete file
const { error } = await supabase.storage
  .from('avatars')
  .remove([`public/${fileName}`])

// Create signed URL for private files (expires after 1 hour)
const { data: signedURL, error } = await supabase.storage
  .from('private-docs')
  .createSignedUrl('document.pdf', 3600)

Edge Functions for Custom Logic

Supabase Edge Functions are serverless TypeScript/JavaScript functions that run on Deno Deploy's global edge network, close to your users for low latency. They enable custom backend logic that goes beyond standard CRUD operations—integrate with third-party APIs like Stripe for payments, send emails via SendGrid, process webhooks, implement complex business logic, perform data transformations, or create custom endpoints not possible with PostgREST alone. Learn Edge Functions development for advanced backend capabilities.

Edge Functions have direct access to your Supabase database using the service role key (bypassing RLS), can call other Supabase services, and execute on every request with cold start times under 200ms. They support environment variables for secrets, TypeScript for type safety, and import npm modules for functionality. Common use cases include payment processing with webhooks, sending transactional emails, generating PDFs, image processing, AI/ML model inference, and integrating with external services that require server-side API keys.

typescriptedge_function_example.ts

// Supabase Edge Function Example
// functions/send-welcome-email/index.ts

import { serve } from 'https://deno.land/[email protected]/http/server.ts'
import { createClient } from 'https://esm.sh/@supabase/supabase-js@2'

serve(async (req) => {
  try {
    // Parse request
    const { userId } = await req.json()
    
    // Create Supabase client with service role (bypass RLS)
    const supabase = createClient(
      Deno.env.get('SUPABASE_URL') ?? '',
      Deno.env.get('SUPABASE_SERVICE_ROLE_KEY') ?? ''
    )
    
    // Get user data
    const { data: user, error } = await supabase
      .from('users')
      .select('email, name')
      .eq('id', userId)
      .single()
    
    if (error) throw error
    
    // Send email via external service
    const emailResponse = await fetch('https://api.sendgrid.com/v3/mail/send', {
      method: 'POST',
      headers: {
        'Authorization': `Bearer ${Deno.env.get('SENDGRID_API_KEY')}`,
        'Content-Type': 'application/json'
      },
      body: JSON.stringify({
        personalizations: [{
          to: [{ email: user.email }]
        }],
        from: { email: '[email protected]' },
        subject: `Welcome ${user.name}!`,
        content: [{
          type: 'text/html',
          value: `<h1>Welcome to our platform!</h1>`
        }]
      })
    })
    
    return new Response(
      JSON.stringify({ success: true }),
      { headers: { 'Content-Type': 'application/json' } }
    )
  } catch (error) {
    return new Response(
      JSON.stringify({ error: error.message }),
      { status: 400, headers: { 'Content-Type': 'application/json' } }
    )
  }
})

// Invoke from client:
// const { data, error } = await supabase.functions.invoke('send-welcome-email', {
//   body: { userId: '123' }
// })

Supabase Studio Dashboard

Supabase Studio is the web-based admin dashboard that provides visual tools for managing every aspect of your Supabase project. It includes a Table Editor for creating and modifying database schemas without writing SQL, SQL Editor with query history and saved queries, Authentication management for viewing users and configuring providers, Storage browser for managing files and buckets, API documentation auto-generated from your schema, Database monitoring with connection stats and query performance, and Edge Functions management for deploying serverless code.

Table Editor: Visual interface for creating tables, adding columns, setting data types, defining constraints, and managing relationships without SQL knowledge
SQL Editor: Write and execute SQL queries with syntax highlighting, autocomplete, query history, and ability to save frequently used queries
Database Schema: Visualize database relationships with ER diagrams, view foreign keys, and understand table connections at a glance
Authentication Panel: Manage users, configure OAuth providers, customize email templates, and view authentication logs and sessions
Storage Browser: Upload, download, organize files in buckets, set access policies, and manage storage quotas through intuitive interface
API Documentation: Auto-generated API reference based on your database schema showing available endpoints, parameters, and example requests
Performance Monitoring: View database metrics, query performance, connection pooling stats, and identify slow queries for optimization
Settings Management: Configure API keys, set up custom domains, manage billing, enable extensions, and control project settings

How Supabase Components Work Together

Understanding how Supabase components integrate creates a complete picture of the architecture. When a user signs up through your application, GoTrue creates a user record in the auth.users table and issues a JWT token. Your application stores this token and includes it in all subsequent requests. When querying data, the Supabase client sends the JWT token to PostgREST which validates it and executes the query against PostgreSQL with the user's context. PostgreSQL's Row Level Security policies examine the JWT (using auth.uid() function) to enforce data access rules, ensuring users only see their own data.

For real-time features, your client subscribes to database changes through the Realtime server via WebSocket connection. The Realtime server listens to PostgreSQL's Write-Ahead Log for changes and broadcasts them to subscribed clients, again respecting RLS policies. File uploads go to the Storage API which stores files in S3-compatible storage, applies RLS policies for access control, and serves them through the integrated CDN. Edge Functions run custom logic with full database access using the service role key, enabling complex operations like payment processing with Stripe integration or sending emails.

The key architectural insight is that PostgreSQL's Row Level Security provides a unified security layer enforced at the database level. Whether data is accessed through PostgREST API, Realtime subscriptions, or Storage policies, the same RLS rules apply—eliminating security inconsistencies common in traditional backends. Learn Row Level Security to master Supabase security.

Self-Hosting and Local Development

Being open source, Supabase can be self-hosted on your own infrastructure using Docker, giving you complete control over data and deployment. The Supabase CLI provides local development environments that mirror production, allowing offline development and testing without cloud connectivity. Self-hosting makes sense for organizations with strict data residency requirements, those wanting to avoid cloud costs at scale, or teams needing custom modifications to Supabase components. Learn local development setup and self-hosting options.

The Supabase CLI (supabase CLI) enables running the entire stack locally including PostgreSQL, PostgREST, GoTrue, Realtime, Storage, and Studio dashboard on your development machine. This supports database migrations with version control, seeding test data, running integration tests offline, and development without affecting production. Changes made locally can be captured as migrations and deployed to production, ensuring database schema consistency across environments.

Key Advantages of Supabase Architecture

Open Source Freedom: No vendor lock-in with MIT licensing, ability to self-host, inspect source code for security audits, and contribute improvements to the ecosystem
PostgreSQL Power: Leverage 35+ years of database development with full SQL, ACID compliance, extensions, advanced indexing, and mature ecosystem
Security by Default: Database-level security with RLS policies applied consistently across all access methods—API, real-time, and storage
Developer Experience: Auto-generated APIs eliminate backend boilerplate, TypeScript support for type safety, comprehensive documentation, and intuitive dashboard
Real-time Capabilities: Built-in WebSocket support for live features without managing infrastructure. Build real-time applications easily
Flexibility: Use as much or as little as needed—just database, just auth, or the full stack; integrate with existing systems or build greenfield projects
Performance: Dedicated database instances, connection pooling, CDN for global file delivery, and edge functions for low-latency custom logic
Cost Effective: Generous free tier for development, predictable pricing that scales with usage, and 4-5x cheaper than Firebase for most workloads. See cost comparison

When to Use Supabase

Supabase excels for applications requiring relational data with complex queries, real-time collaboration features, user authentication with multiple providers, file storage and management, and serverless backend logic. It's particularly well-suited for SaaS applications, mobile apps, web applications, internal tools, MVPs and prototypes, and any project needing a production-ready backend quickly without infrastructure management.

Application Type	Why Supabase Fits	Key Features Used	Example
SaaS Platforms	Multi-tenancy with RLS, user management, subscriptions	PostgreSQL, Auth, RLS, Stripe integration	Project management tools
Mobile Apps	Offline sync, real-time updates, user auth, file storage	Realtime, Storage, Auth, Database	Social media apps
Real-time Apps	Live data sync, presence, collaborative editing	Realtime subscriptions, Broadcast, Presence	Chat, multiplayer games
Content Platforms	Rich data models, full-text search, media storage	PostgreSQL, Storage, Full-text search	Blogs, video platforms
E-commerce	Product catalogs, transactions, user accounts, payments	Database, Auth, Edge Functions, Stripe	Online stores
Internal Tools	Fast development, SQL for analytics, admin access	PostgreSQL, Dashboard, Auth	Admin dashboards

Getting Started with Supabase

Now that you understand Supabase architecture and components, you're ready to start building. The fastest way to get started is creating a free Supabase project which provisions a dedicated PostgreSQL database, authentication system, storage, and all other services in under 2 minutes. Follow our installation and setup guide for detailed instructions on project creation, configuring your development environment, and understanding project settings.

Create Your First Project: Sign up at supabase.com and create a new project. Save your database password securely. See setup guide
Install JavaScript Client: Install @supabase/supabase-js in your project and initialize the client with your project URL and anon key. Learn in SDK guide
Create Database Tables: Use the Table Editor or SQL Editor to create your first table with appropriate columns and data types. Follow database basics
Set Up Authentication: Configure email/password or OAuth providers and implement sign up/login in your application. See authentication guide
Implement Row Level Security: Create RLS policies to secure your data and ensure users only access authorized information. Master RLS implementation
Build a Project: Apply your knowledge by building a complete application like a Todo app with React or Next.js integration

Follow our structured learning path starting with Supabase Tutorial for Beginners, then progress through database fundamentals, authentication, real-time features, and finally build production projects. Our 55-tutorial series takes you from zero to Supabase expert!

Conclusion

Supabase architecture combines proven open-source technologies—PostgreSQL, PostgREST, GoTrue, Realtime, and Deno—into a cohesive platform that provides all the backend services modern applications need. By building on PostgreSQL's solid foundation and adding real-time capabilities, automatic API generation, built-in authentication, and managed file storage, Supabase eliminates infrastructure complexity while maintaining flexibility and transparency through open-source code. The database-first approach with Row Level Security ensures consistent security enforcement across all access methods, making it more secure than traditional application-level permissions. Understanding this architecture enables you to leverage each component effectively—using PostgreSQL for complex queries and data integrity, PostgREST for instant APIs, GoTrue for comprehensive authentication, Realtime for live features, Storage for file management, and Edge Functions for custom logic. Whether building a simple prototype or complex enterprise application, Supabase's modular architecture scales from development to production while remaining cost-effective and avoiding vendor lock-in. Continue your learning journey with our Supabase vs Firebase comparison to understand when to choose Supabase, then follow setup instructions to create your first project and start building production-ready applications with confidence in the underlying architecture.

$ echo $TAGS: #Supabase #Architecture #Backend #PostgreSQL #BaaS

$ share --platform

[X] TWITTER [in] LINKEDIN [f] FACEBOOK

$ cat /comments/ (0)

new_comment.sh

$ cat /comments/

// No comments found. Be the first!