diff --git a/.github/ISSUE_TEMPLATE/config.yml b/.github/ISSUE_TEMPLATE/config.yml
new file mode 100644
index 00000000..ec4bb386
--- /dev/null
+++ b/.github/ISSUE_TEMPLATE/config.yml
@@ -0,0 +1 @@
+blank_issues_enabled: false
\ No newline at end of file
diff --git a/.github/ISSUE_TEMPLATE/feature-request.md b/.github/ISSUE_TEMPLATE/feature-request.md
new file mode 100644
index 00000000..c9ed50fc
--- /dev/null
+++ b/.github/ISSUE_TEMPLATE/feature-request.md
@@ -0,0 +1,27 @@
+# **Titulo da Issue**
+
+## **WHAT**
+<!-- Descreva em detalhes o que a issue precisa que seja feito -->
+
+
+---
+
+## **WHY**
+<!-- Descreva a importância disso para o projeto -->
+
+
+---
+
+## **ADDITIONAL INFO**
+<!-- Adicione aqui links e/ou imagens que possam ajudar quem for desenvolver a issue -->
+
+
+---
+
+## **CHECKLIST**
+<!-- Descreva aqui caso a issue necessite que as coisas sejam feitas em partes  -->
+
+- [ ] item 1
+- [ ] item 2
+
+---
diff --git a/.github/ISSUE_TEMPLATE/feature_request.md b/.github/ISSUE_TEMPLATE/feature_request.md
new file mode 100644
index 00000000..8a06eb3d
--- /dev/null
+++ b/.github/ISSUE_TEMPLATE/feature_request.md
@@ -0,0 +1,36 @@
+---
+name: Feature request
+about: Titulo da Issue
+title: ''
+labels: ''
+assignees: ''
+
+---
+
+# **Titulo da Issue**
+
+## **WHAT**
+<!-- Descreva em detalhes o que a issue precisa que seja feito -->
+
+
+---
+
+## **WHY**
+<!-- Descreva a importância disso para o projeto -->
+
+
+---
+
+## **ADDITIONAL INFO**
+<!-- Adicione aqui links e/ou imagens que possam ajudar quem for desenvolver a issue -->
+
+
+---
+
+## **CHECKLIST**
+<!-- Descreva aqui caso a issue necessite que as coisas sejam feitas em partes  -->
+
+- [ ] item 1
+- [ ] item 2
+
+---
diff --git a/README.md b/README.md
index a64cdbfe..0b72fbd3 100644
--- a/README.md
+++ b/README.md
@@ -8,10 +8,13 @@ A configuração já está dockerizada, então você só precisa ter o Docker Co
 
 - **PHP** 8.3
 - **PostgreSQL** 13
+- **MongoDB**
 - **Nginx**
 - **Symfony** 7
 
-## Começando
+## Instalação 
+<details>
+<summary>Passo a passo</summary>
 
 ### Clonar o Repositório
 
@@ -38,22 +41,60 @@ Execute o Docker Compose para iniciar os contêineres:
 docker-compose up -d
 ```
 
-## Instalação
-
-### Entrar no Contêiner PHP
+### Instalar Dependências
 Para instalar as dependências do projeto, entre no contêiner PHP:
 ```bash
 docker-compose exec -it mapinha-php bash
 ```
 
-### Instalar Dependências
 Dentro do contêiner, execute:
 ```bash
 composer install
 ```
 
-## Uso
+### Uso
 
 Depois que tudo estiver configurado e as dependências instaladas, você pode acessar sua aplicação Symfony em [http://localhost:8080](http://localhost:8080).
 
 Também criei uma rota de teste. Você pode acessá-la em [http://localhost:8080/hello](http://localhost:8080/hello). Esta rota está definida no controller `HelloWorldController` e retorna a mensagem "Bem vind@ ao Mapas Culturais CE".
+
+</details>
+
+
+## Desenvolvimento
+<details>
+<summary>Arquitetura e Decisões técnicas</summary>
+
+Estamos utilizando o Symfony e o seu ecossistma de bibliotecas, porém a arquitetura é baseada em camadas e trata-se de um monolítico com a metodologia API First
+
+```mermaid
+flowchart TD
+    HC((HttpClient)) --JsonRequest<--> R[Routes]
+    B((Browser)) --GET/POST--> Routes
+    R --> CA[[ControllerApi]]
+    Routes --> CW[[ControllerWeb]]
+    CA <--> S[Service]
+    CW <--> S
+    S <--> RP[Repository]
+    RP <==> D[(Database)]
+    CA --JsonResponse--> HC
+    CW --HTML/CSS/JS--> B
+```
+
+Para saber mais sobre nossas decisões técnicas [acesse aqui](./help/README.md)
+</details>
+
+## Design UI/UX
+<details>
+<summary>Informações importantes</summary>
+
+### Prototipação das telas
+A prototipagem das telas é feita por outro time, do RedeMapas, e se encontra [neste link do Figma](https://www.figma.com/design/HkR1qdfHPn4riffcBBOQwR/Prot%C3%B3tipos-%7C-Prioriza%C3%A7%C3%B5es?node-id=0-1&t=n23kLvhTSbEMELhz-0) 
+
+### Componentes web
+Há um fork do Bootstrap (framework css) com a implementação dos protótipos acima, se encontra [neste repositório](https://github.com/secultce/mapaculturaldesign)
+
+### Decisões de Design
+Alguns protótipos implementados não estão seguindo a risca o design sugerido, por decisões totalmente técnicas que estão [documentadas aqui](https://github.com/secultce/mapaculturaldesign/blob/main/help/design-decisions.md)
+</details>
+
diff --git a/help/CREATE-ISSUES.md b/help/CREATE-ISSUES.md
new file mode 100644
index 00000000..3a1ade0b
--- /dev/null
+++ b/help/CREATE-ISSUES.md
@@ -0,0 +1,21 @@
+# Como contribuir criando issues
+
+## Instruções para criar uma nova issue
+
+1 - Navegue até a aba de issues:
+
+Você pode acessar diretamente por aqui https://github.com/secultce/mapinha/issues
+
+2 - Escolha o tipo de issue
+
+Clique em `New Issue` e logo após escolha o tipo de issue:
+- Feature Request
+- Bug Report
+
+3 - Preencha a descrição
+
+Adicione o máximo de informações possíveis, seguindo o template que foi carregado no formulário de criação.
+
+> Lembre-se que provavelmente outra pessoa é quem implementará a mudança, então, tal pessoa precisará do máximo de informações possíveis.
+> 
+> Mesmo que seja você quem for implementar, ainda assim o máximo de detalhes é importante para fins de documentação e auditoria.
diff --git a/help/CREATE-PULL-REQUESTS.md b/help/CREATE-PULL-REQUESTS.md
new file mode 100644
index 00000000..a8d0db92
--- /dev/null
+++ b/help/CREATE-PULL-REQUESTS.md
@@ -0,0 +1,46 @@
+# Pull Requests
+
+1 - Escolha uma issue
+
+Acesse <https://github.com/secultce/mapinha/issues> e escolha em qual issue quer trabalhar
+
+2 - Atualize o seu branch principal (develop)
+
+Para isso você já deve ter uma instalação local desse repositório.
+
+Caso não possua uma instalação, [veja aqui como instalar](./../README.md)
+
+Agora, dentro do diretório atualize seu branch:
+````shell
+git pull origin develop
+````
+
+3 - Crie um branch para a resolução da issue
+
+```shell
+git checkout -b feat/resolve-tal-coisa
+```
+
+4 - Faça os códigos da implementação
+
+Siga as regras da [PSR-12](https://www.php-fig.org/psr/psr-12/), bem como, boas práticas de programação PHP:
+- Kiss
+- Dry
+- Clean Code
+- Design Patterns
+- etc
+
+5 - Execute os testes e o CS-FIXER
+
+Você precisa criar testes que garantam a sua implementação
+Para garantir que você não quebrou nada, e que o código está de acordo com as regras da aplicação, execute os comandos de STYLE CODE e TESTS que se encontra [nessa seção da documentação](../app/README.md#console-commands)
+
+6 - Faça o commit 
+
+A regra, para melhor organização do repositório, é apenas 1 (um) commit por Pull Request
+
+7 - Abra o pull request
+
+Abra o pull request para o projeto `secultce/mapinha` e na descrição do PR informe se há algo a ser levado em consideração, bem como, especifique qual issue aquele pull request está atrelado.
+
+> Pronto, agora é só esperar o seu PR passar pelas validações de testes e code style, e depois ter 2 approves
\ No newline at end of file
diff --git a/help/README.md b/help/README.md
new file mode 100644
index 00000000..917a9f1b
--- /dev/null
+++ b/help/README.md
@@ -0,0 +1,408 @@
+# Mapinha - Arquitetura
+
+Essa é a documentação das decisões tećnicas, voltada para desenvolvedores e/ou entusiastas do código.
+
+<details>
+    <summary>Acesso Rápido</summary>
+    
+[Instalação dos Pacotes](#Instalação)<br>
+[Controller](#API)<br>
+[Repository](#Repository)<br>
+[Command](#Command)<br>
+[Data Fixtures](#Data-Fixtures)<br>
+[Testes](#Testes)<br>
+[Console](#console-commands)<br>
+
+</details>
+
+## Getting Started
+
+### Instalação dos pacotes
+
+Para instalar as dependências e atualizar o autoload, entre no container da aplicação e execute:
+```shell
+composer install
+```
+
+--- 
+
+## Controller
+
+Os `Controllers` em conjunto com as `Routes` permitem criar endpoints para diversas finalidades.
+
+<details>
+<summary>Como criar um novo controller</summary>
+
+#### 1 - Controller
+Crie uma nova classe em `/app/Controller/Api/`, por exemplo, `EventApiController.php`:
+
+```php
+<?php
+
+declare(strict_types=1);
+
+namespace App\Controller\Api;
+
+class EventApiController
+{
+    
+}
+```
+
+#### 2 - Método/Action
+Crie seu(s) método(s) com a lógica de resposta.
+
+> Para gerar respostas em json, estamos utilizando a implementação da `JsonResponse` fornecida pelo pacote do Symfony:
+> Para gerar respostas em HTML, estamos utilizando a implementação da `Response` (`Twig`) fornecida pelo pacote do Symfony:
+
+```php
+<?php
+
+declare(strict_types=1);
+
+namespace App\Controller\Api;
+
+use Symfony\Component\HttpFoundation\JsonResponse;
+use Symfony\Component\HttpFoundation\Response;
+
+class EventApiController
+{
+    public function getList(): JsonResponse
+    {
+        $events = [
+            ['id' => 1, 'name' => 'Palestra'],
+            ['id' => 2, 'name' => 'Curso'],
+        ];   
+    
+        return new JsonResponse($events);
+    }
+    
+    public function getList(): Response
+    {
+        $events = [
+            ['id' => 1, 'name' => 'Palestra'],
+            ['id' => 2, 'name' => 'Curso'],
+        ];   
+    
+        return $this->render('view.html.twig', $events);
+    }
+}
+```
+
+#### 3 - Rotas
+
+Acesse os arquivos das rotas em `/config/routes` lá nós estamos separando as rotas em API e Web
+
+```yaml
+get:
+  path: /example
+  controller: App\Controller\Admin\ExampleAdminController::action
+  methods: ['GET']
+```
+
+Atente-se para seguir o padrão, um arquivo `.yaml` por controller
+
+#### 4 - Pronto
+
+Feito isso, seu endpoint deverá estar disponivel em:
+<http://localhost:8080/o-que-voce-definiu-como-path>
+
+E deve estar retornando um JSON ou uma página web, dependendo da action que você criou.
+
+</details>
+
+---
+
+## Repository
+
+A camada responsável pela comunicação entre nosso código e o banco de dados.
+
+<details>
+<summary>Como criar um novo repository</summary>
+
+Siga o passo a passo a seguir:
+
+#### Passo 1 - Crie sua classe no `/app/src/Repository` e extenda a classe abstrata `AbstractRepository`
+
+```php
+<?php
+
+declare(strict_types=1);
+
+namespace App\Repository;
+
+class MyRepository extends AbstractRepository
+{
+}
+```
+
+#### Passo 2 - Defina a Entity principal que esse repositório irá gerenciar
+
+```php
+
+use Doctrine\Persistence\ManagerRegistry;
+use App\Entity\MyEntity;
+...
+
+public function __construct(ManagerRegistry $registry)
+{
+    parent::__construct($registry, MyEntity::class);
+}
+```
+
+</details>
+
+---
+
+## Migrations
+Migrations são a forma (correta) de fazer um versionamento do banco de dados, nesta parte da aplicação isso é fornecido pela biblioteca `doctrine/migrations` mas no core do MapaCultural isso ainda é feito por uma decisão técnica interna chamada `db-updates.php`
+
+<details>
+<summary>Como criar uma nova migration</summary>
+
+#### Passo 1 - Criar uma nova classe no diretório `/app/migrations`
+
+```php
+<?php
+
+declare(strict_types=1);
+
+namespace App\Migrations;
+
+use Doctrine\DBAL\Schema\Schema;
+use Doctrine\Migrations\AbstractMigration;
+
+final class Version20241231235959 extends AbstractMigration
+{
+    public function up(Schema $schema): void
+    {
+        //$this->addSql('CREATE TABLE ...');
+    }
+    
+    public function down(Schema $schema): void
+    {
+        //$this->addSql('DROP TABLE ...');
+    }
+}
+```
+
+Note que o nome da classe deve informar o momento de sua criação, para que seja mantida uma sequencia temporal da evolução do esquema do banco de dados.
+
+> Documentação oficial das migrations do Doctrine: <https://www.doctrine-project.org/projects/doctrine-migrations/en/3.8/reference/generating-migrations.html>
+</details>
+
+## Command
+Comandos são entradas via CLI (linha de comando) que permitem automatizar alguns processos, como rodar testes, veririfcar estilo de código, e debugar rotas
+
+<details>
+<summary>Como criar um novo console command</summary>
+
+#### Passo 1 - Criar uma nova classe em `app/src/Command/`:
+
+```php
+<?php
+
+namespace App\Command;
+
+use Symfony\Component\Console\Command\Command;
+use Symfony\Component\Console\Input\InputInterface;
+use Symfony\Component\Console\Output\OutputInterface;
+
+class MyCommand extends Command
+{
+    protected static string $defaultName = 'app:my-command';
+    
+    protected function execute(InputInterface $input, OutputInterface $output): int
+    {
+        $output->writeln('Hello World!');
+        
+        return Command::SUCCESS;  
+    }
+} 
+```
+
+#### Passo 2 - Testar seu comando no CLI
+
+Entre no container da aplicação PHP e execute isso
+
+```shell
+php bin/console app:my-command
+```
+
+Você deverá ver na tela o texto `Hello World!`
+
+#### Passo 3 - Documentação do pacote
+Para criar e gerenciar os nosso commands estamos utilizando o pacote `symfony/console`, para ver sua documentação acesse:
+
+> Saiba mais em <https://symfony.com/doc/current/console.html>
+
+Para ver outros console commands da aplicação acesse a seção [Console Commands](#console-commands)
+
+</details>
+
+---
+
+## Data Fixtures
+Data Fixtures são dados falsos, normalmente criados para testar a aplicação, algumas vezes são chamados de "Seeders".
+
+<details>
+<summary>Como criar uma DataFixture para uma Entidade</summary>
+
+#### Passo 1 - Criar uma nova classe em `app/src/DataFixtures/`:
+
+```php
+<?php
+
+namespace App\DataFixtures;
+
+use Doctrine\Persistence\ObjectManager;
+use MapasCulturais\Entities\Agent;
+
+class AgentFixtures extends Fixture
+{
+    public function load(ObjectManager $manager): void
+    {
+        $agent = new Agent();
+        $agent->name = 'Agente Teste da Silva';
+        
+        $manager->persist($agent);
+        $manager->flush();
+    }
+} 
+```
+
+#### Passo 2 - Executar sua fixture no CLI
+
+Entre no container da aplicação PHP e execute isso
+
+```shell
+php bin/console doctrine:fixtures:load
+```
+
+Pronto, você deverá ter um novo Agente criado de acordo com a sua Fixture.
+
+> Saiba mais sobre DataFixtures em <https://www.doctrine-project.org/projects/doctrine-data-fixtures/en/1.7/index.html>
+
+</details>
+
+---
+
+## Testes
+Estamos utilizando o PHPUnit para criar e gerenciar os testes automatizados, focando principalmente nos testes funcionais, ao invés dos testes unitários.
+
+Documentação do PHPUnit: <https://phpunit.de/index.html>
+
+<details>
+<summary>Como criar um novo teste</summary>
+
+### Criar um novo teste
+Para criar um no cenário de teste funcional, basta adicionar sua nova classe no diretório `/app/tests/functional/`, com o seguinte código:
+
+```php
+<?php
+
+namespace App\Tests\Functional;
+
+class MeuTest extends AbstractTestCase
+{
+    
+}
+```
+
+Adicione dentro da classe os cenários que você precisa garantir que funcionem, caso precise imprimir algo na tela para "debugar", utilize o método `dump()` fornecido pela classe `AbstractTestCase`:
+
+```php
+public function testIfOneIsOne(): void
+{
+    $list = ['Mar', 'Minino'];
+    
+    $this->dump($list); // equivalente ao print_r
+    
+    $this->assertEquals(
+        'MarMinino',
+        implode('', $list)
+    );
+}
+```
+
+Para executar os testes veja a seção <a href="#console-commands">Console Commands</a>
+</details>
+
+---
+
+## DI (Injeção de dependência)
+A injeção de dependência já acontece automaticamente pela própria estrutura do Symfony
+
+## Console Commands
+
+<details>
+<summary>CACHE CLEAR</summary>
+
+### Limpar cache
+Para executar o comando de limpar cache basta entrar no container da aplicação e executar o seguinte comando:
+
+```shell
+php bin/console cache:clear
+```
+
+</details>
+
+<details>
+<summary>COMMAND SQL</summary>
+
+### Executar código SQL
+Para executar um comando SQL basta entrar no container da aplicação e executar o seguinte comando:
+
+```shell
+php bin/console doctrin:query:sql {sql}
+```
+O argumento chamado de `sql` é requerido e é o comando a ser executar no banco de dados.
+</details>
+
+<details>
+<summary>TESTS</summary>
+
+### Testes Automatizados
+Para executar os testes, entre no container da aplicação e execute o seguinte comando:
+
+```shell
+php bin/phpunit {path}
+```
+
+O `path` é opcional, o padrão é "/tests"
+</details>
+
+<details>
+<summary>STYLE CODE</summary>
+
+### Style Code
+Para executar o PHP-CS-FIXER basta entrar no container da aplicação e executar
+
+```shwll
+php bin/console app:code-style
+```
+</details>
+
+<details>
+<summary>DATA FIXTURES</summary>
+
+### Debug router
+Para listas as routas basta entrar no container da aplicação e executar
+```
+php bin/console debug:router
+```
+
+> Podemos usar as flags --show-actions e --show-controllers
+</details>
+
+<details>
+<summary>DOCTRINE</summary>
+
+### Doctrine
+Para listas todos os comandos disponiveis para gerenciamento do banco de dados através do doctrine basta entrar no container da aplicação e executar
+```
+php bin/doctrine
+```
+
+</details>
+