# Overview

This section features a step-by-step guide to getting started with TypeDB using a simple social network that includes people, friendships, employments, and organizations. You will not need to install anything - run TypeDB server in the cloud for free, and interact with it via the web-based TypeDB Studio.

It is intended to give a quick rundown of the main interactions you’ll have with TypeDB, such as database management, schema definition, data loading, and composing multi-step queries.

## [](#_mini_guide)Mini-guide

The following outline serves both as an example of the main things you’ll do with TypeDB and a quick outline of the following Quickstart guide - if you just want to speed through right here, you can, though we recommend following the full guide!

1.  [Setup](../setup/index.md)
    
    1.  Sign up & launch a free TypeDB instance on [TypeDB Cloud account](https://cloud.typedb.com).
        
    2.  Follow the instructions from the cluster to open [TypeDB Studio](https://studio.typedb.com).
        
    
2.  [Create a schema](../schema/index.md)
    
    1.  Create a database called `get_started`.
        
    2.  Execute a query to create the social network schema using a schema transaction:
        
        ```typeql
        #!test[schema]
        define
        attribute username,
         value string;
        attribute start-date,
         value datetime;
        attribute status,
         value string;
        attribute student-count,
         value integer;
        entity user,
          owns status @card(0..),
          owns username @key,
          plays enrolment:student,
          plays friendship:friend;
        entity organization,
          owns status,
          owns username,
          plays friendship:friend;
        entity company,
          sub organization;
        entity university,
          sub organization,
          owns student-count,
          plays enrolment:university;
        relation friendship,
          relates friend @card(2..2),
          owns start-date @card(0..1);
        relation enrolment,
          relates student,
          relates university;
        ```
        
    
3.  [Create data](../data/index.md)
    
    1.  Run a series of pure inserts using a write transaction:
        
        ```typeql
        #!test[write]
        insert $u0 isa user, has username "alice";
        ```
        
        ```typeql
        #!test[write]
        insert
        $u1 isa user, has username "bob";
        $u2 isa user;
        $u2 has username "charlene";  # can split `isa` and `has` across different statements
        ```
        
        ```typeql
        #!test[write]
        insert
        $u3 isa user, has username "delta";
        $u4 isa user, has username "echo";
        $u5 isa user, has username "fizzbuzz";
        friendship (friend: $u3, friend: $u4);
        friendship (friend: $u3, friend: $u5);
        ```
        
    2.  Run a read-write query:
        
        ```typeql
        #!test[write, count=1]
        match
        $x isa user, has username "alice";
        $y isa user, has username "bob";
        insert
        friendship (friend: $x, friend: $y), has start-date 2015-01-01T00:00:00;
        ```
        
    
4.  Use your loaded schema and data to write aggregation queries, compose query pipelines, and create functions in [Query composition](../query-composition/index.md)
    
5.  Optional: [Configure coding agent](../../../home/configure-coding-agent/index.md)
    
    1.  Install `typeql-check` from your package manager (the same channels as TypeDB Console).
        
    2.  Drop `typedb-skills/typeql.md` into your coding agent so it can write TypeQL for you.
        
    

[Quickstart: Basics](../index.md) [Setup](../setup/index.md)

[Edit on GitHub](https://github.com/typedb/typedb-docs/edit/3.x-development/learn-typedb/modules/ROOT/pages/quickstart/overview.adoc) Edit this page on GitHub.