diff --git a/docs/guide-pt-BR/start-databases.md b/docs/guide-pt-BR/start-databases.md
index 0360b4a813..ac9740125c 100644
--- a/docs/guide-pt-BR/start-databases.md
+++ b/docs/guide-pt-BR/start-databases.md
@@ -12,11 +12,11 @@ Através deste tutorial, você aprenderá como:
 * Configurar uma conexão de BD
 * Definir uma classe de Active Record
 * Consultar dados usando a classe de Active Record
-* Exibir dados em uma view de modo paginado
+* Exibir dados em uma view de forma paginada
 
 Perceba que para terminar essa seção, você deve ter conhecimento e experiência
 básica usando bancos de dados. Em particular, você deveria saber como criar um
-banco de dados, e como executar declarações SQL usando uma ferramente de cliente
+banco de dados, e como executar instruções SQL usando uma ferramenta de cliente
 de BD.
 
 
@@ -86,7 +86,7 @@ através da qual você pode fazer consultas de SQL ao banco de dados subjacente.
 A conexão de BD configurada acima pode ser acessada no código da aplicação
 através da expressão `Yii::$app->db`.
 
-> Info: O arquivo `config/db.php` será incluso pela configuração principal da
+> Informação: O arquivo `config/db.php` será incluso pela configuração principal da
   aplicação `config/web.php`, que especifica como a instância da [aplicação](structure-applications.md)
   deverá ser inicializada. Para mais informações, por favor consulte a seção sobre [Configurações](concept-configurations.md).
 
@@ -114,7 +114,7 @@ A classe `Country` estende de [[yii\db\ActiveRecord]]. Você não precisa escrev
 nenhum código nela! Só com o código acima, o Yii adivinhará o nome da tabela
 associada a partir do nome da classe.
 
-> Info: Se não houver nenhuma correspondência direta do nome da classe com o nome
+> Informação: Se não houver nenhuma correspondência direta do nome da classe com o nome
   da tabela, você pode sobrescrever o método [[yii\db\ActiveRecord::tableName()]] 
   para especificar explicitamente o nome da tabela associada.
 
@@ -138,8 +138,8 @@ $country->name = 'U.S.A.';
 $country->save();
 ```
 
-> Info: O Active Record é uma maneira poderosa de acessar e manipular os dados
-  do banco de dados de um modo orientado a objeto. Você pode encontrar informações
+> Informação: O Active Record é uma maneira poderosa de acessar e manipular os dados
+  do banco de dados de uma forma orientada a objeto. Você pode encontrar informações
   mais detalhadas na seção [Active Record](db-active-record.md). Alternativamente,
   você também pode interagir com o banco de dados usando um método de acesso aos
   dados de baixo nível chamado [Data Access Objects](db-dao.md).
@@ -242,7 +242,7 @@ os dados dos países com a página correspondente.
 Testando <a name="trying-it-out"></a>
 --------
 
-Para verificar se todo o código acima funciona, use o seu navegador para
+Para verificar se todo os códigos acima funcionam, use o seu navegador para
 acessar a seguinte URL:
 
 ```
diff --git a/docs/guide-pt-BR/start-forms.md b/docs/guide-pt-BR/start-forms.md
new file mode 100644
index 0000000000..edb8dc6d0f
--- /dev/null
+++ b/docs/guide-pt-BR/start-forms.md
@@ -0,0 +1,270 @@
+Trabalhando com Formulários
+===========================
+
+Nesta seção descreve como se cria uma nova página com um formulário para obter
+dados a partir dos usuários. A página exibirá uma formulário com um campo para 
+o nome e uma para o e-mail. Depois de obter essas duas informações a partir do 
+usuário, a página exibirá os valores inseridos de volta para a confirmação.
+
+Para atingir este objetivo, além de criar uma [ação](structure-controllers.md) (action) e 
+duas [visões](structure-views.md) (view), você também criará uma [modelo](structure-models.md) (model).
+
+Através deste tutorial, você aprenderá como:
+
+* Criar um [modelo](structure-models.md) (model) para representar os dados inseridos pelo usuário por meio de um formulário
+* Declarar regras (rules) para validar os dados inseridos
+* Criar um formulário HTML em uma [visão](structure-views.md) (view)
+
+
+Criando uma Modelo (Model) <a name="creating-model"></a>
+----------------
+
+Os dados a serem solicitados pelo usuário será representados por uma classe modelo
+`EntryForm` como mostro a seguir e salvos no arquivo `models/EntryForm.php`. Por 
+favor consulte a seção [Autoloading de Classes](concept-autoloading.md) para mais 
+detalhes sobre convenção de nomenclatura dos arquivos de classes.
+
+```php
+<?php
+
+namespace app\models;
+
+use yii\base\Model;
+
+class EntryForm extends Model
+{
+    public $name;
+    public $email;
+
+    public function rules()
+    {
+        return [
+            [['name', 'email'], 'required'],
+            ['email', 'email'],
+        ];
+    }
+}
+```
+
+A classe estende de [[yii\base\Model]], uma classe base fornecida pelo Yii, 
+comumente usados para representar dados do formulário.
+
+> Informação: O [[yii\base\Model]] é usado como pai das classes modelos que *não* 
+são associadas com tabelas do banco de dados.
+O [[yii\db\ActiveRecord]] é normalmente usado como pai das classes modelos que 
+correspondem a tabelas do banco de dados.
+
+A classe `EntryForm` contém dois atributos públicos, `name` e `email`, que são 
+usados para guardar os dados fornecidos pelo usuário. Ele também contém um método
+chamado `rules()`, que retorna um conjunto de regras para validação dos dados. 
+As regras de validação declaradas no código acima permitem que:
+
+* tanto os valores do `name` quanto do `email` sejam obrigatórios
+* os dados do `email` devem ser um e-mail válido sintaticamente
+
+Se você tiver um objeto `EntryForm` populado com dados fornecidos pelo usuário,
+você pode chamar o [[yii\base\Model::validate()|validate()]] para iniciar as 
+rotinas de validação dos dados. A validação dos dados falhar, a propriedade 
+[[yii\base\Model::hasErrors|hasErrors]] será definida como *true* e você pode
+saber quais erros ocorrerão pela validação através de [[yii\base\Model::getErrors|errors]].
+
+```php
+<?php
+$model = new EntryForm();
+$model->name = 'Qiang';
+$model->email = 'bad';
+if ($model->validate()) {
+    // Bom!
+} else {
+    // Falha!
+    // Utilize $model->getErrors()
+}
+```
+
+
+Criando uma Ação <a name="creating-action"></a>
+------------------
+
+Em seguida, você precisará criar uma ação `entry` no controlador `site` que será usado no novo modelo. O processo de criação e utilização das ações são explicadas na seção 
+[Como Fazer um "Hello World"](start-hello.md).
+
+```php
+<?php
+
+namespace app\controllers;
+
+use Yii;
+use yii\web\Controller;
+use app\models\EntryForm;
+
+class SiteController extends Controller
+{
+    // ...código existente...
+
+    public function actionEntry()
+    {
+        $model = new EntryForm;
+
+        if ($model->load(Yii::$app->request->post()) && $model->validate()) {
+            // dados válidos recebidos pelo $model
+
+            // fazer alguma coisa aqui sobre $model ...
+
+            return $this->render('entry-confirm', ['model' => $model]);
+        } else {
+            // Ou a página é exibida inicialmente ou existe algum erro de validação
+            return $this->render('entry', ['model' => $model]);
+        }
+    }
+}
+```
+
+A primeira ação cria um objeto `EntryForm`. Ele, então, tenta popular o modelo 
+(model) com os dados vindos do `$_POST`, fornecidos pelo [[yii\web\Request::post()]]
+no Yii. Se o modelo (model) for populado com sucesso (por exemplo, se o usuário
+enviar o formulário HTML), a ação chamará o [[yii\base\Model::validate()|validate()]] 
+para certifique-se que os valores fornecidos são válidos.
+
+> Informação: A expressão `Yii::$app` representa a instância da 
+  [aplicação](structure-applications.md), que é globalmente acessível via singleton. 
+  Também é um [service locator](concept-service-locator.md) que fornece componentes 
+  tais como `request`, `response`, `db`, etc. para suportar a funcionalidade específica.
+  No código acima, o componente `request` da instância da aplicação é usada para
+  acessar os dados do `$_POST`.
+
+Se tudo tiver certo, a ação renderizará a visão chamada `entry-confirm` para 
+confirmar os dados enviados pelo usuário. Se ao enviar o formulário não 
+houver dados ou se os dados tiverem erros, a visão `entry` será renderizada, 
+em que o formulário será exibigo, juntamente com as mensagens de erros da 
+validação.
+
+> Nota: Neste exemplo muito simples, acabamos de renderizar um página de confirmação
+  mediante a dados válidos enviados de uma formulário. Em prática, você poderia 
+  considerar usar [[yii\web\Controller::refresh()|refresh()]] ou [[yii\web\Controller::redirect()|redirect()]]
+  para evitar [problemas ao reenviar formulários](http://en.wikipedia.org/wiki/Post/Redirect/Get).
+
+
+Criando Visões <a name="creating-views"></a>
+--------------
+
+Finalmente, crie dois arquivos de visões chamados de `entry-confirm` e `entry`. 
+Estas visões serão renderizados pela ação `entry`, como descrito anteriormente.
+
+A visão `entry-confirm` simplesmente exibe os dados dos campos `name` e `email`. 
+Deverá ser salvo no arquivo `views/site/entry-confirm.php`.
+
+```php
+<?php
+use yii\helpers\Html;
+?>
+<p>You have entered the following information:</p>
+
+<ul>
+    <li><label>Name</label>: <?= Html::encode($model->name) ?></li>
+    <li><label>Email</label>: <?= Html::encode($model->email) ?></li>
+</ul>
+```
+
+A visão `entry` exibe um formulário HTML. Deverá ser salvo no arquivo `views/site/entry.php`.
+
+```php
+<?php
+use yii\helpers\Html;
+use yii\widgets\ActiveForm;
+?>
+<?php $form = ActiveForm::begin(); ?>
+
+    <?= $form->field($model, 'name') ?>
+
+    <?= $form->field($model, 'email') ?>
+
+    <div class="form-group">
+        <?= Html::submitButton('Submit', ['class' => 'btn btn-primary']) ?>
+    </div>
+
+<?php ActiveForm::end(); ?>
+```
+
+A visão usa o poderoso [widget](structure-widgets.md) chamado 
+[[yii\widgets\ActiveForm|ActiveForm]] para criar o formulário HTML. Os métodos 
+`begin()` e `end()` do widget renderizam a abertura e o fechamento da tag do 
+formulário. Entre os dois métodos chamados, os campos de entrada são criados pelo
+método [[yii\widgets\ActiveForm::field()|field()]]. O primeiro campo de entrada
+é para o "name" (nome) e o segundo é para o "email". Após os campos de entrada,
+o método [[yii\helpers\Html::submitButton()]] é chamado para criar o botão 
+de enviar.
+
+
+Testando <a name="trying-it-out"></a>
+-------------
+
+Para ver como ele funciona, utilize seu navegador para acessar a seguinte URL:
+
+```
+http://hostname/index.php?r=site/entry
+```
+
+Você verá uma página exibindo um formulário com dois campos de entrada. Na frente 
+de cada campo, um *label* indicando quais dados devem ser inseridos. Se você clicar
+no botão de enviar sem informar nenhum dado, ou se você não fornecer um e-mail 
+válido, você verá uma mensagem de erro após cada campo de entrada.
+
+![Form with Validation Errors](images/start-form-validation.png)
+
+Após informar um nome e e-mail válidos e clicar no botão de enviar, você verá uma 
+nova página exibindo os dados informados por você.
+
+![Confirmation of Data Entry](images/start-entry-confirmation.png)
+
+
+
+### Explicação da Mágica <a name="magic-explained"></a>
+
+Você pode querer saber como o formulário HTML trabalha por baixo dos panos, porque 
+parece quase mágica exibir um *label* para cada campo de entrada e mostrar mensagens
+de erro quando você não informa dados corretos sem recarregar a página.
+
+Sim, a validação dos dados inicialmente é feito no lado do cliente usando JavaScript
+e posteriormente realizada no lado do servidor via PHP.
+O [[yii\widgets\ActiveForm]] é inteligente o suficiente para extrair as regras de 
+validação declaradas no `EntryForm`, transformando-as em códigos JavaScript e utilizando 
+o JavaScript para realizar as validações dos dados. No caso do JavaScript estiver desabilitado
+em seu navegador, a validação ainda será realizada pelo lado do servidor, como mostrado
+no método `actionEntry()`. Isso garante que os dados serão validados em qualquer 
+circunstância.
+
+> Aviso: A validação feita pelo lado do cliente é uma conveniência que fornece uma melhor
+  experiência para o usuário. A validação feita pelo lado do servidor é sempre necessária
+  com ou sem validação no lado do cliente.
+
+Os *labels* dos campos de entrada são geradas pelo método `field()`, usando os nomes 
+das propriedades do modelo (model).
+Por exemplo, um *label* chamado `Name` será gerado para a propriedade `name`. 
+
+Você pode personalizar um *label* em uma visão utilizando o seguinte código:
+
+```php
+<?= $form->field($model, 'name')->label('Your Name') ?>
+<?= $form->field($model, 'email')->label('Your Email') ?>
+```
+
+> Informação: O Yii fornece muitos destes widgets para lhe ajudar a criar rapidamente
+  complexas e dinâmicos layouts.
+  Como você vai aprender mais tarde, escrever um novo widget é também extremamenet fácil.
+  Você pode querer transformar grande parte do seu código de visão em reutilizáveis 
+  widget para simplificar o desenvolvimento de visões no futuro.
+
+ 
+Resumo <a name="summary"></a>
+-------
+
+Nesta seção, você tocou em cada parte do padrão de arquitetura MVC. 
+Aprendeu como criar uma classe modelo (model) para representar os dados do usuário 
+e validá-los.
+
+Também aprendeu como obter os dados enviados pelos usuários e como exibi-los de
+volta no navegador. Esta é uma tarefa que poderia levar muito tempo ao desenvolver
+uma aplicação, mas o Yii fornece widgets inteligentes para gerar estas tarefas de 
+forma simples.
+Na próxima seção, você aprenderá como trabalhar com banco de dados, os quais são 
+necessários em quase todas as aplicações.
diff --git a/docs/guide-pt-BR/start-gii.md b/docs/guide-pt-BR/start-gii.md
index 79f5dfcdda..60144bd411 100644
--- a/docs/guide-pt-BR/start-gii.md
+++ b/docs/guide-pt-BR/start-gii.md
@@ -14,7 +14,7 @@ Através desse tutorial, você irá aprender a:
 Começando a usar o Gii <a name="starting-gii"></a>
 ------------
 
-[Gii](tool-gii.md) é fornecido com o Yii como um [módulo](structure-modules.md). Você pode habilitar o Gii ao configurá-lo na propriedade [[yii\base\Application::modules|modules]] da aplicação. Dependendo de como você criou sua aplicação, você pode já encontrar o seguinte código no arquivo de configuração `config/web.php`:
+O [Gii](tool-gii.md) é fornecido com o Yii como um [módulo](structure-modules.md). Você pode habilitar o Gii ao configurá-lo na propriedade [[yii\base\Application::modules|modules]] da aplicação. Dependendo de como você criou sua aplicação, você pode já encontrar o seguinte código no arquivo de configuração `config/web.php`:
 
 ```php
 $config = [ ... ];
@@ -68,7 +68,7 @@ Ao usar o Gii, se você já havia criado o mesmo arquivo e pretende sobrescrevê
 
 ![Pré-visualização do Gerador de Modelo](images/start-gii-model-preview.png)
 
-Quando estiver sobrescrevendo um arquivo, marque a caixa próxima a "sobrescrever" e clique no botão "Gerar". Se estiver criando um arquivo novo, apenas clique em "Gerar".
+Quando estiver sobrescrevendo um arquivo, marque a caixa próxima a "overwrite" (sobrescrever) e clique no botão "Generate". Se estiver criando um arquivo novo, apenas clique em "Generate".
 
 Em seguida, você verá uma página de confirmação indicando que o código foi gerado com sucesso. Se você já tinha um arquivo, também verá uma mensagem indicando que ele foi sobrescrito com o novo código.
 
@@ -76,7 +76,7 @@ Em seguida, você verá uma página de confirmação indicando que o código foi
 Gerando código CRUD <a name="generating-crud"></a>
 --------------------
 
-CRUD corresponde a Create, Read, Update, and Delete (criar, ler, atualizar e apagar), representando as quatro tarefas comuns feitas com os dados na maioria dos sites. Para criar funcionalidades CRUD usando o Gii, selecione "Gerador CRUD" clicando no link na página inicial do Gii. Seguindo o exemplo "country", preencha o formulário com as seguintes informações:
+CRUD corresponde a Create, Read, Update, and Delete (criar, ler, atualizar e apagar), representando as quatro tarefas comuns feitas com os dados na maioria dos sites. Para criar funcionalidades CRUD usando o Gii, selecione "CRUD Generator" clicando no link na página inicial do Gii. Seguindo o exemplo "country", preencha o formulário com as seguintes informações:
 
 * Classe do Modelo: `app\models\Country`
 * Classe da Busca: `app\models\CountrySearch`
@@ -116,7 +116,7 @@ Essa é uma lista de arquivos gerados pelo Gii, caso você queira investigar com
 * Modelo: `models/Country.php` e `models/CountrySearch.php`
 * Views: `views/country/*.php`
 
-> Info: o Gii é projetado para ser uma ferramenta altamente adaptável e extensível. Usando-o sabiamente, você irá acelerar o desenvolvimento da sua aplicação. Para mais detalhes, por favor siga para a seção [Gii](tool-gii.md).
+> Informação: o Gii é projetado para ser uma ferramenta altamente adaptável e extensível. Usando-o sabiamente, você irá acelerar o desenvolvimento da sua aplicação. Para mais detalhes, por favor siga para a seção [Gii](tool-gii.md).
 
 
 Resumo <a name="summary"></a>
diff --git a/docs/guide-pt-BR/start-looking-ahead.md b/docs/guide-pt-BR/start-looking-ahead.md
index 47dd89f68b..9de82f2b77 100644
--- a/docs/guide-pt-BR/start-looking-ahead.md
+++ b/docs/guide-pt-BR/start-looking-ahead.md
@@ -4,7 +4,7 @@ Seguindo em Frente
 Se você leu a seção "Primeiros Passos" inteira, você criou uma aplicação Yii
 completa. Neste processo, você aprendeu como implementar algumas funcionalidades
 comumente necessárias, tais como obter dados de usuários através de um formulário
-HTML, consultar dados de um banco de dados, e exibir os dados de modo paginado.
+HTML, consultar dados de um banco de dados, e exibir os dados de forma paginada.
 Você também aprendeu a usar o [Gii](tool-gii.md) para gerar código automaticamente.
 Usar o Gii para a geração de código torna a carga do seu processo de desenvolvimento
 Web uma tarefa tão simples quanto preencher alguns formulários.
@@ -13,25 +13,25 @@ Esta seção resume as referências sobre o Yii que lhe ajudarão a ser mais pro
 usando o framework.
 
 * Documentação
-    - O Guia Definitivo:
+    - [O Guia Definitivo](http://www.yiiframework.com/doc-2.0/guide-README.html):
       Conforme o nome indica, o guia define precisamente como o Yii deve funcionar
       e fornece orientações gerais sobre como usar o Yii. É o tutorial
       mais importante, e que você deveria ler antes de escrever qualquer código
       com o Yii.
-    - A Referência de Classes (Class Reference):
+    - [A Referência de Classes](http://www.yiiframework.com/doc-2.0/index.html):
       Especifica o uso de todas as classes disponibilizadas pelo Yii. Deve ser
       principalmente usado quando você estiver escrevendo o código e quiser entender
       o uso de uma classe, método ou propriedade em particular. O uso da referência
       de classes só é melhor depois de um entendimento contextual do framework
       inteiro.
-    - Os Artigos do Wiki:
+    - [Os Artigos do Wiki](http://www.yiiframework.com/wiki/?tag=yii2):
       Os artigos do wiki escritos pelos usuários do Yii baseados em suas próprias
       experiências. A maioria deles são escritos como receitas de bolo, e mostram
       como resolver problemas em particular usando o Yii. Enquanto a qualidade destes
       artigos pode não ser tão boa quanto a do Guia Definitivo, eles ainda assim
       são úteis porque são mais abrangentes e frequentemente fornecem
       soluções prontas para serem usadas.
-    - Livros
+    - [Livros](http://www.yiiframework.com/doc/)
 * [Extensões](http://www.yiiframework.com/extensions/):
   O Yii ostenta uma biblioteca de milhares de extensões contribuídas por usuários,
   que podem facilmente ser plugadas em suas aplicações, desta forma tornando
diff --git a/docs/guide-pt-BR/start-workflow.md b/docs/guide-pt-BR/start-workflow.md
index 3a5f0bfaba..e055098124 100644
--- a/docs/guide-pt-BR/start-workflow.md
+++ b/docs/guide-pt-BR/start-workflow.md
@@ -7,7 +7,7 @@ dependendo da sua configuração. Esta seção introduzirá a funcionalidade emb
 da aplicação, como o código é organizado, e como a aplicação manuseia as requisições
 em geral.
 
-> Info: Por questões de simpicidade, por todo este tutorial de "Primeiros Passos"
+> Info: Por questões de simplicidade, por todo este tutorial de "Primeiros Passos"
   assume-se que você definiu `basic/web` como a raiz de documentos do seu
   servidor Web, e configurou a URL de acesso de sua aplicação como `http://hostname/index.php`
   ou algo semelhantes. Por favor ajuste as URLs em nossas descrições às suas
@@ -17,7 +17,7 @@ em geral.
 Funcionalidade <a name="functionality"></a>
 --------------
 
-A aplicação básica contém quatro páginas:
+A aplicação básica instalada contém quatro páginas:
 
 * A página inicial, exibida quando você acessa a URL `http://hostname/index.php`,
 * a página "About" (Sobre),
@@ -65,7 +65,7 @@ Em geral, os arquivos na aplicação podem ser divididos em dois tipos: aqueles
 diretamente via HTTP (ou seja, em um navegador), enquanto os segundos não podem
 e nem deveriam.
 
-O Yii implementa o padrão de projeto [modelo-visão-controlador (MVC)](http://wikipedia.org/wiki/Model-view-controller),
+O Yii implementa o padrão de arquitetura [modelo-visão-controlador (MVC)](http://wikipedia.org/wiki/Model-view-controller),
 que se reflete na organização de diretórios acima. O diretório `models` contém
 todas as [classes de modelos](structure-models.md), o diretório `views` contém todos
 os [scripts de visões](structure-views.md), e o diretório `controllers` contém
@@ -77,7 +77,7 @@ O diagrama a seguir demonstra a estrutura estática de uma aplicação.
 
 Cada aplicação tem um script de entrada `web/index.php` que é o único script PHP
 acessível pela Web na aplicação. O script de entrada recebe uma requisição e
-cria uma instância da [aplicação](structure-applications.md) para manejá-la.
+cria uma instância da [aplicação](structure-applications.md) para gerenciá-la.
 A [aplicação](structure-applications.md) resolve a requisição com a ajuda de seus
 [componentes](concept-components.md), e despacha a requisição para os elementos
 do MVC. São usados [Widgets](structure-widgets.md) nas [views](structure-views.md)
@@ -91,7 +91,7 @@ O diagrama a seguir demonstra como uma aplicação gerencia uma requisição.
 
 ![Ciclo de Vida da Requisição](images/request-lifecycle.png)
 
-1. Um usuário faz uma requisiçao ao [script de entrada](structure-entry-scripts.md) `web/index.php`.
+1. Um usuário faz uma requisição ao [script de entrada](structure-entry-scripts.md) `web/index.php`.
 2. O script de entrada carrega a [configuração](concept-configurations.md) da
    aplicação e cria uma instância da [aplicação](structure-applications.md) para
    gerenciar a requisição.
@@ -99,8 +99,8 @@ O diagrama a seguir demonstra como uma aplicação gerencia uma requisição.
    componente de aplicação [request](runtime-requests.md).
 4. A aplicação cria uma instância de um [controller](structure-controllers.md)
    para gerenciar a requisição.
-5. O controller cria uma instância da [action](structure-controllers.md) (ação)
-   e aplica os filtros da ação.
+5. O controller cria uma instância de um [action](structure-controllers.md) (ação)
+   e aplica os filtros para a ação.
 6. Se qualquer filtro falhar, a ação é cancelada.
 7. Se todos os filtros passarem, a ação é executada.
 8. A ação carrega um modelo de dados, possivelmente a partir de um banco de dados.
diff --git a/docs/guide-pt-BR/structure-entry-scripts.md b/docs/guide-pt-BR/structure-entry-scripts.md
index 094b2baedc..dd5068b4cf 100644
--- a/docs/guide-pt-BR/structure-entry-scripts.md
+++ b/docs/guide-pt-BR/structure-entry-scripts.md
@@ -2,7 +2,7 @@ Scripts de Entrada
 ==================
 
 Scripts de entrada são o primeiro passo no processo de inicialização da aplicação.
-Uma aplicação (seja uma aplicação Web ou do console) possui um único script de
+Uma aplicação (seja uma aplicação Web ou uma aplicação console) possui um único script de
 entrada. Os usuários finais fazem requisições a scripts de entrada que criam
 as instâncias da aplicação e redirecionam as requisições para elas.
 
@@ -27,7 +27,7 @@ O trabalho principal dos scripts de entrada é o seguinte:
 * Chamar [[yii\base\Application::run()]] para processar as requisições que chegam.
 
 
-## Aplicações da Web <a name="web-applications"></a>
+## Aplicações Web <a name="web-applications"></a>
 
 Este é o código no script de entrada para o [Modelo Básico de Aplicação Web](start-installation.md).
 
@@ -51,7 +51,7 @@ $config = require(__DIR__ . '/../config/web.php');
 ```
 
 
-## Aplicações do Console <a name="console-applications"></a>
+## Aplicações Console <a name="console-applications"></a>
 
 De forma semelhante, o seguinte é o código do script de entrada de uma aplicação
 do console:
diff --git a/docs/guide-pt-BR/structure-overview.md b/docs/guide-pt-BR/structure-overview.md
index 79e13c4f1d..7d97bbe466 100644
--- a/docs/guide-pt-BR/structure-overview.md
+++ b/docs/guide-pt-BR/structure-overview.md
@@ -15,7 +15,7 @@ Além do MVC, as aplicações do Yii também possuem as seguintes entidades:
   ciclo de tratamento de uma requisição.
 * [aplicações](structure-applications.md): são objetos globalmente acessíveis que
   gerenciam os componentes da aplicação e os coordenam para atender às requisições.
-* [componentes de aplicação](structure-application-components.md): são objetos
+* [componentes da aplicação](structure-application-components.md): são objetos
   registrados com as aplicações e fornecem vários serviços para atender às
   requisições.
 * [módulos](structure-modules.md): são pacotes auto-contidos que contém um MVC