<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Claud Watari on Medium]]></title>
        <description><![CDATA[Stories by Claud Watari on Medium]]></description>
        <link>https://medium.com/@claudwatari?source=rss-bc9a15dfa479------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/0*ZrqWmBZcI08oH1iq.jpg</url>
            <title>Stories by Claud Watari on Medium</title>
            <link>https://medium.com/@claudwatari?source=rss-bc9a15dfa479------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Fri, 20 Nov 2026 15:22:19 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@claudwatari/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Neat Linux Tips: Postgres Password Change]]></title>
            <link>https://medium.com/@claudwatari/neat-linux-tips-postgres-password-change-ff3e6fa2beaf?source=rss-bc9a15dfa479------2</link>
            <guid isPermaLink="false">https://medium.com/p/ff3e6fa2beaf</guid>
            <category><![CDATA[password-management]]></category>
            <category><![CDATA[linux]]></category>
            <category><![CDATA[postgres]]></category>
            <category><![CDATA[postgresql]]></category>
            <category><![CDATA[ubuntu]]></category>
            <dc:creator><![CDATA[Claud Watari]]></dc:creator>
            <pubDate>Mon, 02 Nov 2026 20:19:56 GMT</pubDate>
            <atom:updated>2026-11-02T20:19:56.740Z</atom:updated>
            <content:encoded><![CDATA[<ul><li>To change your postgres password:</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*IADE_45mYnMy_adP2dmzgw.png" /><figcaption>apocalyptic workstation executing Linux Postgre password change (made with AI by the author)</figcaption></figure><p>When you loose your postgres password, you cannot recover it, you can only replace it or generate a new one and below is how to do it in linux ubuntu:</p><p>In your Terminal app screen type:</p><p>— psql</p><p>Or if your user is restricted, access with root:</p><p>— sudo -u postgres psql</p><p>Execute below query:</p><p>ALTER USER your_username WITH PASSWORD ‘new_secure_password’;</p><p>Exit</p><p>\q or type “exit”</p><p>Test new connection:</p><p>— psql -U your_username -d postgres -h localhost</p><p>It should prompt you for a password, enter your new password and it should log you in.</p><p>If you cannot log into psql at all because it rejects your credentials, you will need to temporarily configure Postgres to let anyone log in locally without a password, change it, and then restore the security settings.</p><ol><li><strong>Locate and Edit pg_hba.conf:</strong>Configuration File.</li></ol><p>Find your pg_hba.conf file (locations vary by OS, e.g., /etc/postgresql/{version}/main/pg_hba.conf on Linux or /Library/PostgreSQL/{version}/data on macOS). Open it with a text editor using administrative privileges.</p><p><em>Verification:</em> You see lines detailing connection methods (like local, host).</p><p><strong>2. Temporarily Change Authentication Method:</strong>Config Edit.</p><p>Find the line for local connections (usually starts with local all all peer or local all all md5) and change the authentication method to trust.</p><p><em>Example:</em> Change local all all peer to local all all trust. Save the file.</p><p><em>Verification:</em> The file saves with trust as the method for local access.</p><p><strong>3. Restart the PostgreSQL Service:</strong>Service Management.</p><p>Restart the database server to apply the configuration change:</p><ul><li>Linux (systemd): sudo systemctl restart postgresql</li><li>macOS (Homebrew): brew services restart postgresql</li><li><em>Verification:</em> The service restarts without errors.</li></ul><p><strong>4. Log In and Reset Password:</strong>Terminal.</p><p>Run psql -U postgres (it will let you in without a password). Then run:</p><p>SQL</p><pre>ALTER USER your_username WITH PASSWORD &#39;new_secure_password&#39;;</pre><p><em>Verification:</em> Postgres responds with ALTER ROLE. Exit with \q.</p><p><strong>5. Restore pg_hba.conf and Restart:</strong>Security Cleanup.</p><p>Revert the change you made in pg_hba.conf back to its original setting (peer or md5), save it, and restart the PostgreSQL service one final time.</p><p><em>Verification:</em> Trying to log in without a password now correctly fails, but logging in with your <em>new</em> password works.</p><p><strong>To see your table schema and relationships from the Terminal screen</strong></p><p>psql “postgres://postgres:&lt;password&gt;@localhost:5432/&lt;db-name&gt;” -c ‘\d &lt;table-name&gt;’</p><p>Note: Angle braces are inclusive of the replace-able string</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=ff3e6fa2beaf" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Redeploying a Node.js .tar.gz Project on AWS EC2 Using CloudShell]]></title>
            <link>https://medium.com/@claudwatari/redeploying-a-node-js-tar-gz-project-on-aws-ec2-using-cloudshell-c4e9577fab02?source=rss-bc9a15dfa479------2</link>
            <guid isPermaLink="false">https://medium.com/p/c4e9577fab02</guid>
            <category><![CDATA[aws-s3]]></category>
            <category><![CDATA[aws-ec2]]></category>
            <category><![CDATA[nodejs]]></category>
            <category><![CDATA[linux]]></category>
            <category><![CDATA[prisma]]></category>
            <dc:creator><![CDATA[Claud Watari]]></dc:creator>
            <pubDate>Tue, 27 Oct 2026 19:08:09 GMT</pubDate>
            <atom:updated>2026-10-27T19:30:45.065Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*nvg9Zudlophu7ngitjI1Mg.jpeg" /></figure><p>Assume you already have a Node.js application deployed to an AWS EC2 instance from a .tar.gz archive. You have since made changes locally and want to update the deployed files to match your latest version.</p><p>If you are familiar with building a project locally and restarting a Windows service, the idea is similar: transfer the updated application, replace the deployed files, and restart the server process.</p><p>With AWS, you can perform these steps using AWS CloudShell and Systems Manager Session Manager (SSM), provided your EC2 instance is configured for SSM access.</p><h3>1. Package the Updated Project Locally</h3><p>From your project directory, create an archive containing the files required to run the application:</p><p>Bash</p><pre>tar -czf app.tar.gz dist package.json package-lock.json</pre><p>Adjust the archive contents to match your project structure. Include other required files (such as Prisma assets, configuration templates, or migration files) where applicable. Do not package secrets or local development dependencies unnecessarily.</p><p>For example, excluding unneeded files:</p><p>Bash</p><pre>tar -czf app-backup.tar.gz \<br>  --exclude=&#39;.env&#39; \<br>  --exclude=&#39;.env.*&#39; \<br>  --exclude=&#39;node_modules&#39; \<br>  --exclude=&#39;.git&#39; \<br>  --exclude=&#39;app.tar.gz&#39; \<br>  .</pre><h4>1.a. Debugging: tar: dist: Cannot stat: No such file or directory</h4><p>If you encounter a compression error on your local machine:</p><p>Plaintext</p><pre>tar: dist: Cannot stat: No such file or directory<br>tar: Exiting with failure status due to previous errors</pre><p>This indicates that the tar command cannot find the dist directory in your current working directory. In a Node.js project, this usually happens because the production build has not been generated yet, the project uses a different output directory, or you are executing the command from the wrong folder.</p><h4>1.b. Confirm Your Current Directory</h4><p>Run:</p><p>Bash</p><pre>pwd<br>ls -la</pre><p>Confirm that you are inside the root directory of your Node.js project (where package.json resides). If you are in the wrong directory, navigate to your project root:</p><p>Bash</p><pre>cd /path/to/your/project</pre><h4>1.c. Check Whether the Build Directory Exists &amp; Generate the Production Build</h4><p>Run ls -la to see if dist exists. If your project requires source files instead of a dist build output, archive the source files directly:</p><p>Bash</p><pre>tar -czf app.tar.gz \<br>  app.js \<br>  package.json \<br>  package-lock.json \<br>  prisma.config.ts \<br>  prisma/ \<br>  src/ \<br>  helpers/</pre><p>Wait for the build/archive to complete successfully, then verify that the archive was created:</p><p>Bash</p><pre>ls -la</pre><p><em>Note: You can rename </em><em>app.tar.gz to match your projected output filename if you use versioning (e.g., </em><em>app-v2.tar.gz).</em></p><h3>2. Upload the Archive to AWS CloudShell</h3><p>Now that the application archive has been created successfully, upload it to AWS CloudShell:</p><ul><li>Open the <strong>AWS Management Console</strong> and launch <strong>CloudShell</strong> in the AWS Region where your deployment resides.</li><li>In the CloudShell interface, open <strong>Actions → Upload file</strong>.</li><li>Select app.tar.gz from your local computer and upload it.</li></ul><p>Once the upload completes, verify that the file exists in CloudShell:</p><p>Bash</p><pre>ls -lh app.tar.gz</pre><h4>2.a. Confirm the Archive Location in CloudShell</h4><p>Verify the exact path of your uploaded archive in CloudShell:</p><p>Bash</p><pre>ls -lh ~/app.tar.gz</pre><p>The expected location is /home/cloudshell-user/app.tar.gz. Ensure the filename matches what you use in subsequent transfer commands.</p><p><em>Important: CloudShell and your EC2 instance have separate filesystems. Uploading the archive to CloudShell does not automatically transfer it to your EC2 instance.</em></p><h3>3. Transfer the Archive to the EC2 Instance</h3><p>There are several ways to transfer files from CloudShell to an EC2 instance. A reliable option is to use an Amazon S3 bucket as an intermediary, particularly when the instance is managed through AWS Systems Manager (SSM).</p><h4>3.a. Upload the Archive from CloudShell to Amazon S3</h4><p>From CloudShell, upload the archive to your S3 deployment bucket:</p><p>Bash</p><pre>aws s3 cp ~/app.tar.gz \<br>  s3://YOUR-BUCKET/deployments/app.tar.gz \<br>  --region [region-code]</pre><p><em>(Replace </em><em>YOUR-BUCKET and the </em><em>--region flag with your actual bucket name and AWS Region).</em></p><h4>3.b. Verify the S3 Upload</h4><p>Verify that the file is present in the S3 bucket before proceeding:</p><p>Bash</p><pre>aws s3 ls s3://YOUR-BUCKET/deployments/ \<br>  --region [region-code]</pre><h4>3.c. Transfer the File from S3 to EC2 via SSM (or Directly on EC2)</h4><p>You can trigger the download on EC2 using SSM Run Command directly from CloudShell:</p><p>Bash</p><pre>aws ssm send-command \<br>  --instance-ids i-YOUR-INSTANCE-ID \<br>  --document-name AWS-RunShellScript \<br>  --parameters &#39;commands=[&quot;aws s3 cp s3://YOUR-BUCKET/deployments/app.tar.gz /tmp/app.tar.gz --region your-region&quot;]&#39;</pre><p>Alternatively, connect directly to your EC2 instance (via SSM Session Manager or SSH) and run:</p><p>Bash</p><pre>aws s3 cp \<br>  s3://YOUR-BUCKET/deployments/app.tar.gz \<br>  /tmp/app.tar.gz \<br>  --region [your-region]</pre><p><em>Note: The EC2 instance must have the AWS CLI installed and an attached IAM role with permissions to read from the target S3 bucket.</em></p><h3>4. Back Up the Existing Application</h3><p>Before replacing deployed files, create a backup of the current application on the server.</p><p>For example, if your application lives at /opt/app:</p><p>Bash</p><pre>sudo tar -czf /tmp/app-backup.tar.gz \<br>  -C /opt app</pre><p>Verify that the backup was created successfully:</p><p>Bash</p><pre>ls -lh /tmp/app-backup.tar.gz</pre><p><em>Note: Storing backups on the same instance is useful for fast rollbacks, but off-instance storage (like S3) is recommended for production disaster recovery.</em></p><h3>5. Inspect and Extract the Updated Application</h3><h4>5.a. Debugging: tar: Cannot open: No such file or directory</h4><p>If you attempt to inspect or extract the archive on EC2 and encounter:</p><p>Plaintext</p><pre>tar (child): /tmp/app.tar.gz: Cannot open: No such file or directory<br>tar (child): Error is not recoverable: exiting now</pre><p>This means the tar command cannot locate /tmp/app.tar.gz on the current machine. Confirm whether you are connected to the EC2 instance or still inside CloudShell.</p><p>If needed, start an SSM session to connect to your EC2 instance from CloudShell:</p><p>Bash</p><pre>aws ssm start-session --target i-YOUR-INSTANCE-ID --region YOUR-REGION-CODE</pre><h4>5.b. Verify the Archive on EC2</h4><p>Once connected to the EC2 instance, confirm the archive exists in /tmp:</p><p>Bash</p><pre>ls -lh /tmp/app.tar.gz</pre><p>Inspect its contents without extracting:</p><p>Bash</p><pre>tar -tzf /tmp/app.tar.gz</pre><h4>5.c. Extract the Archive</h4><p>Extract the archive into your target deployment directory:</p><p>Bash</p><pre>sudo tar -xzf /tmp/app.tar.gz \<br>  -C /opt/app</pre><p><em>Caution: Extracting an archive over an existing directory does not delete files that were removed in the new local build. For production deployments, using versioned directories with symlinks is recommended.</em></p><h3>6. Install Dependencies and Prepare Prisma</h3><p>Because the archive contains package.json and package-lock.json but excludes node_modules, install the required dependencies on the EC2 instance:</p><p>Bash</p><pre>cd /opt/app<br>npm ci --omit=dev</pre><p><em>(If your project requires dev-dependencies to generate build artifacts or Prisma clients, run </em><em>npm ci without </em><em>--omit=dev).</em></p><h4>6.a. Generate Prisma Client</h4><p>If your application uses Prisma, generate the client for the target environment:</p><p>Bash</p><pre>npx prisma generate</pre><h4>6.b. Verify Environment Variables &amp; Database Migrations</h4><ul><li>Ensure production environment variables (.env) are present on the server (do not package .env files inside your build archives).</li><li>Execute database migrations (npx prisma migrate deploy) only when required by the release and after verifying target database safety.</li></ul><h3>7. Restart the Node.js Service</h3><p>If your application process is managed by systemd, restart the service:</p><p>Bash</p><pre>sudo systemctl restart app</pre><p>Verify the status of the service:</p><p>Bash</p><pre>sudo systemctl status app --no-pager</pre><p><em>(If using PM2, Docker, or another process manager, use the corresponding restart commands).</em></p><h3>8. Verify the Deployment</h3><p>A successful service restart does not automatically guarantee full application health.</p><h4>8.a. Inspect Service Logs</h4><p>Check the latest logs for runtime errors or missing configurations:</p><p>Bash</p><pre>sudo journalctl -u app -n 100 --no-pager</pre><h4>8.b. Health Checks &amp; Endpoint Validation</h4><p>Verify the following checklist:</p><ul><li>[ ] Service starts clean without crashing.</li><li>[ ] Database connectivity is active.</li><li>[ ] Prisma client connects without schema mismatch.</li><li>[ ] Required environment variables are loaded.</li><li>[ ] HTTP health checks or critical API endpoints return 200 OK.</li></ul><h3>9. Final Thoughts</h3><p>Redeploying a Node.js application on EC2 involves more than simply copying files and restarting a process. Archive integrity, file paths, dependency management, environment security, and process management all play key roles.</p><p>For high-availability production environments, consider automated CI/CD pipelines (e.g., AWS CodeDeploy, GitHub Actions) or containerized workflows to simplify rollbacks and deployment reliability.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=c4e9577fab02" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The Backend Was Working. The Database Was Working. Prisma Had Other Plans.]]></title>
            <link>https://medium.com/@claudwatari/the-backend-was-working-the-database-was-working-prisma-had-other-plans-97ca138f4b3b?source=rss-bc9a15dfa479------2</link>
            <guid isPermaLink="false">https://medium.com/p/97ca138f4b3b</guid>
            <category><![CDATA[nodejs]]></category>
            <category><![CDATA[aws]]></category>
            <category><![CDATA[deployment]]></category>
            <category><![CDATA[postgresql]]></category>
            <category><![CDATA[prisma]]></category>
            <dc:creator><![CDATA[Claud Watari]]></dc:creator>
            <pubDate>Thu, 08 Oct 2026 17:37:27 GMT</pubDate>
            <atom:updated>2026-10-08T17:39:58.003Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*VwwgTDfjz6gSqO-3Y49zTw.jpeg" /></figure><p>I had a Node.js/Express backend that needed a proper AWS home. Not “let’s throw the application onto an EC2 instance with a public IP and hope for the best” proper, but a setup with some actual separation between the internet, the application, and the database. I wanted the public-facing part of the system to be deliberately small, while keeping the application server and PostgreSQL database private. The final shape I was aiming for was simple enough to draw on a napkin: <strong>Internet → Application Load Balancer → private EC2 → private RDS PostgreSQL</strong>.</p><p>This article is my record of how I built that environment, partly as technical documentation and partly because I know perfectly well that six months from now I will stare at an AWS console and ask myself, <em>“Why did I do this again?”</em> 😭 So rather than relying entirely on future-me’s questionable memory, or asking an AI to reconstruct my own infrastructure, I am documenting the decisions, commands, configuration, mistakes, and little AWS surprises as I go. The goal is not to pretend everything was difficult; it’s to leave behind a practical reference for rebuilding or troubleshooting the setup when I inevitably need it again.</p><p>Before creating any infrastructure, I started by establishing the AWS account context I would be working in. The deployment was going into the <strong>Africa (Cape Town) region (</strong><strong>af-south-1)</strong>, so I made the region explicit in the CLI commands rather than relying on whatever region happened to be configured in the shell. I also checked the identity currently being used from AWS CloudShell. This is a small step, but it is one I don&#39;t want to skip in future deployments: when you&#39;re creating IAM roles, security groups, VPC resources, EC2 instances, and databases, knowing exactly <strong>which AWS account and identity you&#39;re operating as</strong> is much cheaper than discovering later that you built everything in the wrong place.</p><p>I used AWS STS to verify the active identity:</p><pre>aws sts get-caller-identity</pre><p>This returned the account and IAM identity I was operating under. From there, I could safely continue with the infrastructure work. The important lesson here is that AWS CLI commands are very happy to execute without asking whether you <em>meant</em> to be in this account or region. I therefore treated the account identity and region as part of the deployment configuration itself, rather than as background information I could afford to forget. Future me: <strong>check the account, check the region, then start clicking things.</strong></p><p>With the AWS account and region confirmed, I created a dedicated VPC for the application rather than using the default VPC. The default VPC was left untouched because there was no reason to modify infrastructure that wasn’t part of this deployment. The new VPC uses 10.0.0.0/16, giving us a large private address space to work with while keeping the addressing scheme simple. I named it backend-app-uat-vpc-vpc so that the purpose of the network would remain obvious when looking at the AWS console or querying resources from the CLI later.</p><p>The basic VPC was created with:</p><pre>aws ec2 create-vpc \<br>  --cidr-block 10.0.0.0/16 \<br>  --region af-south-1 \<br>  --tag-specifications &#39;ResourceType=vpc,Tags=[{Key=Name,Value=backend-app-name-uat-vpc-vpc}]&#39;</pre><p>The resulting VPC became the boundary for the rest of the application infrastructure. I then planned the network across two Availability Zones, with public subnets for resources that genuinely need internet-facing connectivity and private subnets for the application and database layers. The important design decision was that <strong>private does not mean “the server has no way out”; it means the server isn’t directly reachable from the internet</strong>. The application would eventually be able to reach external services through controlled outbound networking, while inbound traffic would be restricted to the components that actually needed to communicate with it.</p><p>I divided the VPC into four subnets across two Availability Zones. The two public subnets are 10.0.0.0/20 in af-south-1a and 10.0.16.0/20 in af-south-1b; these are where the internet-facing Application Load Balancer would eventually live. The two private subnets are 10.0.128.0/20 in af-south-1a and 10.0.144.0/20 in af-south-1b; these are reserved for internal application and database resources. Splitting the network this way also gives the deployment resources in two Availability Zones rather than putting the entire stack into one physical AWS failure domain.</p><p>I then created an Internet Gateway and attached it to the VPC. The Internet Gateway is what allows the public subnets to have a route to the internet; importantly, simply attaching an Internet Gateway does <strong>not</strong> make every resource inside the VPC publicly reachable. Routing and security-group rules still determine what can actually communicate. The gateway was created with:</p><pre>aws ec2 create-internet-gateway \<br>  --region af-south-1 \<br>  --tag-specifications &#39;ResourceType=internet-gateway,Tags=[{Key=Name,Value=backend-application-uat-vpc-igw}]&#39;</pre><p>I then attached the resulting Internet Gateway to the application VPC:</p><pre>aws ec2 attach-internet-gateway \<br>  --internet-gateway-id &lt;internet-gateway-id&gt; \<br>  --vpc-id &lt;vpc-id&gt; \<br>  --region af-south-1</pre><p>The &lt;...&gt; values here are intentionally placeholders rather than live resource identifiers. In the actual deployment, AWS returned the resource IDs which were then used by the subsequent networking commands.</p><p>Creating public and private subnets is only half the job; AWS needs explicit route tables to know where traffic should go. I created a public route table for the ALB subnets and added a default route (0.0.0.0/0) through the Internet Gateway. The private subnets received their own route table instead of sharing the public one. This separation is important: the application and database resources should not suddenly become internet-facing just because they happen to live inside the same VPC. I associated the two public subnets with the public route table and the two private subnets with the private route table.</p><p>For the private network’s outbound connectivity, I created a NAT Gateway in a public subnet and gave it an Elastic IP. This allows resources such as the private EC2 instance to initiate outbound connections when necessary — for example, downloading packages or communicating with external APIs — without giving those resources public IP addresses or allowing unsolicited inbound connections. The resulting traffic pattern is therefore asymmetric in the useful way: <strong>private resources can go out through NAT, but the internet cannot simply initiate a connection back to them.</strong> The private route table uses the NAT Gateway as its default route, while the public route table uses the Internet Gateway. I also planned the S3 Gateway Endpoint separately so traffic from the private network to S3 could remain within AWS rather than unnecessarily traversing the NAT Gateway.</p><p>Before creating the application server, I added an S3 Gateway Endpoint to the VPC. This was useful for the deployment process because the private EC2 instance needed to retrieve deployment artifacts from S3 without requiring a public IP. A Gateway Endpoint is different from the interface endpoints I would later create for Systems Manager: it integrates with the VPC route tables and provides private access to S3. I associated the endpoint with the private route tables, so traffic destined for S3 could use the AWS-managed S3 path rather than travelling through the NAT Gateway. This also meant the deployment architecture had a clean separation between general outbound traffic and AWS service traffic that could remain inside the AWS network.</p><p>I then started defining the security boundaries for the actual application. Instead of allowing the EC2 instance to accept traffic from the entire internet, I created a dedicated security group for the Application Load Balancer and another for the application server. The ALB security group would eventually allow HTTP traffic from the internet, while the EC2 security group would allow port 4000 only from the ALB security group. The application server therefore doesn&#39;t need to know or trust individual public IP addresses; it trusts the load balancer as its upstream component. The ALB security group was created with:</p><pre>aws ec2 create-security-group \<br>  --group-name backend-app-alb-sg \<br>  --description &quot;Security group for my application ALB&quot; \<br>  --vpc-id &lt;vpc-id&gt; \<br>  --region af-south-1</pre><p>I kept the database security group separate as well. The eventual rule would be similarly restrictive: PostgreSQL port 5432 would be accepted by RDS only from the EC2 application&#39;s security group. This gave the infrastructure a simple security model that could be read almost like a sentence: <strong>the internet can reach the ALB, the ALB can reach the application, and the application can reach the database.</strong></p><p>With the network foundation in place, I created the security group for the application EC2 instance. At creation time, I deliberately left its inbound rules empty. This is a useful starting point for a private server: rather than opening port 22 because “I&#39;ll need SSH later,” I started from zero and added only the traffic the architecture actually required. Once the ALB existed, I added a single inbound rule allowing TCP port nnnn from the ALB security group. The result was that the application could receive requests from its intended upstream component without exposing its application port directly to the internet.</p><p>For administration, I chose AWS Systems Manager Session Manager instead of SSH. This meant the EC2 instance could remain completely private while still giving me an interactive shell when I needed one. I created an IAM role for EC2 and attached the AWS-managed AmazonSSMManagedInstanceCore policy, allowing the Systems Manager agent on the instance to communicate with the required AWS services. I then attached that role to the EC2 instance during provisioning. No public IPv4 address was required, and no inbound SSH rule was created. Once the instance was running, I could open a shell through Session Manager and work on the server as ssm-user, using sudo for administrative operations. This became one of the nicest parts of the setup: <strong>the server was private, but I could still get inside it whenever I needed to.</strong></p><p>Because the EC2 instance had no public IP and was intended to remain private, Systems Manager needed a private path to the AWS services it depended on. I therefore created three VPC interface endpoints for Systems Manager: <strong>SSM</strong>, <strong>SSMMessages</strong>, and <strong>EC2Messages</strong>. I enabled private DNS on the endpoints and placed them in both private application subnets. A dedicated endpoint security group was also created, allowing HTTPS traffic from the application EC2 security group. This meant the instance could communicate with Systems Manager entirely through the VPC rather than needing internet access merely to maintain remote-management connectivity. At this point the architecture had a rather satisfying property: I could remove the public internet from the server’s inbound story entirely and still have a usable administrative shell.</p><p>I then launched the EC2 instance itself using Amazon Linux 2023 on a t3.micro, with an encrypted gp3 root volume and a dedicated key pair retained for the environment. The instance was placed in the first private application subnet and associated with the application security group and the Systems Manager IAM role. I also enabled termination and stop protection because accidentally killing the application server while experimenting with AWS would be a particularly stupid way to spend an afternoon. The instance came up with a private address only, passed its status checks, and appeared as a managed node in Systems Manager. From there, I opened a Session Manager shell and verified that I could administer the machine without exposing SSH or assigning it a public IP.</p><p>With the EC2 instance reachable through Session Manager, I started preparing the operating environment for the backend. I verified the machine’s access to the private network and installed the tools needed for deployment, including Git and the Node.js runtime. The application was going to run directly on the EC2 instance rather than inside a container, so keeping the host environment predictable was important. I also created a dedicated application directory at /opt/backend-app and used the ssm-user account for the application files, while retaining sudo access for system-level operations. This gave me a clean separation between the operating system and the application itself instead of scattering project files throughout the user&#39;s home directory.</p><p>I deliberately excluded node_modules, .git, and environment files from the deployment archive. The source was packaged locally and temporarily transferred through a private S3 bucket, after which the EC2 instance downloaded and extracted the archive into /opt/backend-app. The deployment archive therefore contained the application source, Prisma schema and migrations, package.json, lockfile, and supporting files, but <strong>not the production secrets</strong>. The production .env file was transferred separately and later locked down with restrictive filesystem permissions. This was a small deployment, but I wanted the process to establish a pattern I could reuse: source code can be moved around as an artifact, while credentials remain a separate piece of configuration.</p><p>The next major component was PostgreSQL. I created an RDS subnet group containing the two private subnets in separate Availability Zones and then created a dedicated security group for the database. The database security group was intentionally narrow: PostgreSQL access was permitted only from the EC2 application’s security group. The RDS instance itself was provisioned as a PostgreSQL database in the private subnets, with encryption enabled, automated backups configured, and public accessibility disabled. This gave the application a real managed database while keeping the database completely outside the public network path. At this point the core internal architecture was taking shape: the EC2 instance could communicate with RDS, but neither the database nor the application server needed to be directly exposed to the internet.</p><p>I then installed the application dependencies on EC2 and configured its production environment. The backend uses Prisma with the PostgreSQL adapter, so after placing the production DATABASE_URL in the application&#39;s .env, I generated the Prisma client and deployed the existing migrations to the empty RDS database. I verified the resulting schema with Prisma&#39;s database introspection and confirmed that the application&#39;s models had been created successfully. The backend itself was configured to run as a systemd service, which meant the Node process could start independently of my Session Manager shell and automatically restart if it exited. By this stage, the application server and database were both alive inside the private network; the remaining job was to put a controlled public entry point in front of the backend and prove that the entire request path worked end-to-end.</p><p>There were a few smaller implementation details that turned out to matter just as much as the major AWS resources. The EC2 filesystem was explicitly owned by the application user rather than root, while the production .env was restricted to owner-only permissions. The application was run under systemd with Restart=always, and I verified that Node was actually listening on the expected application interface before putting the load balancer in front of it. I also kept the temporary deployment S3 bucket separate from the application&#39;s permanent infrastructure and used server-side encryption for the environment file stored there. The S3 access granted to the EC2 IAM role was intentionally narrow — it was a temporary deployment permission rather than something I wanted to become a permanent part of the server&#39;s privileges.</p><p>One particularly useful part of the process was testing each layer independently instead of treating “the API doesn’t work” as one giant problem. First, I verified that Systems Manager could reach the private EC2 instance. Then I verified the Node process locally on the server. RDS connectivity was tested independently using PostgreSQL, including an SSL-enabled connection, before relying on Prisma. Prisma itself was then generated against the deployed schema and the migrations were applied to the new database. Finally, the Application Load Balancer was configured with the private EC2 instance as its target and its health check confirmed that the backend was reachable. This layered approach made debugging considerably less mystical: when something failed, I could ask <strong>which boundary is broken?</strong> rather than randomly changing credentials, routes, security groups, and AWS settings until something started working.</p><p>The resulting infrastructure is intentionally modest, but it has the important properties I wanted from the beginning: the ALB is the public-facing component; the Node.js application runs on a private EC2 instance; PostgreSQL runs on private RDS; security groups define the permitted communication paths; Systems Manager provides administrative access without exposing SSH; NAT provides controlled outbound internet access for private resources; and the S3 Gateway Endpoint provides private access to S3 from the VPC. In shorthand, the architecture is <strong>Internet → public ALB → private application EC2 → private PostgreSQL RDS</strong>, with AWS-managed services providing the supporting plumbing around it. And this is where the story gets slightly less dignified: after all of that infrastructure was working, the backend was still not completely happy. The database was there, the credentials were correct, Prisma could introspect it, and yet an actual API request produced a database access error. Naturally, the next thing I had to debug was Prisma itself.</p><p>The EC2 instance needed an identity of its own. Rather than attaching broad administrative permissions to the server, I created a dedicated IAM role for EC2 and attached the AWS-managed AmazonSSMManagedInstanceCore policy. This role exists specifically so the instance can register with and communicate through Systems Manager. The distinction between an IAM user and an EC2 IAM role is important here: my own AWS identity was used to create and administer infrastructure, while the EC2 role represents the permissions granted to the machine itself. That keeps the server from inheriting my personal administrative privileges simply because I happen to be the person who created it.</p><p>The trust relationship for the role allows the EC2 service to assume it, after which the instance receives temporary AWS credentials through its instance metadata mechanism. Once the instance was running, I verified that Systems Manager could see it as a managed node and opened a Session Manager shell. The shell identified me as ssm-user, while sudo remained available for operating-system administration. This gave me the operational equivalent of SSH without requiring an inbound SSH rule or a public IP. It also meant that the server&#39;s administrative path was controlled through IAM and Systems Manager rather than through a permanently exposed network service.</p><p>Because the EC2 instance was private, I then created the Systems Manager interface endpoints inside the VPC. The three endpoints were for ssm, ssmmessages, and ec2messages, and they were placed in both private subnets with private DNS enabled. I created a dedicated security group for these endpoints and allowed HTTPS access from the application EC2 security group. The important detail is that the endpoint security group trusts the server, while the server does not need to accept inbound traffic from the endpoints. The connection is initiated by the EC2 instance, travels through the VPC endpoint, and reaches Systems Manager privately.</p><p>The endpoint arrangement also meant I could test the private-server model before deploying the application. If Session Manager worked while the EC2 instance had no public address and no SSH ingress, I knew the administrative path was correctly separated from the application’s eventual public path. This became a useful design principle for the rest of the deployment: <strong>don’t make something public just because you need to manage it. Give it the narrowest private path that actually solves the problem.</strong></p><p>Once the network and management path were ready, I launched the application server. The instance was provisioned using Amazon Linux 2023, x86_64 architecture, and a t3.micro instance type. I placed it directly into the first private application subnet and associated the application security group and the EC2 Systems Manager IAM role. The root volume was an encrypted gp3 volume with 30 GiB of storage. I also enabled termination protection and stop protection. These settings aren&#39;t particularly glamorous, but they are the sort of things that become very important when you&#39;re experimenting in a real AWS account and suddenly realize that terminate-instances is a remarkably unforgiving command.</p><p>The instance came up with only a private IPv4 address and passed both EC2 status checks. I connected to it through Session Manager and started preparing the operating system. The application directory was created at /opt/backend-app, and the project files were eventually owned by ssm-user:ssm-user so that the application could operate without needing to run as root. I installed the Node.js runtime and npm, then verified the versions before installing the project&#39;s dependencies. The deployment deliberately used npm ci rather than a fresh npm install, because the repository already contained a lockfile and I wanted the server to install the dependency tree represented by that lockfile as closely as possible.</p><p>The application itself was then transferred to the instance as a compressed deployment artifact. Before creating the archive, I excluded node_modules, Git metadata, and all environment files:</p><pre>tar \<br>  --exclude=node_modules \<br>  --exclude=.git \<br>  --exclude=.env \<br>  --exclude=&#39;.env.*&#39; \<br>  -czf /tmp/backend-app.tar.gz .</pre><p>This produced a portable application archive without dragging local dependencies or production secrets along with it. The archive was temporarily uploaded to an S3 bucket created specifically for the deployment, and the private EC2 instance downloaded it through the VPC’s S3 Gateway Endpoint. I extracted the application under /opt/backend-app and corrected the ownership afterward. This gave me a repeatable deployment path without putting the source code into a public repository or requiring the private EC2 instance to have a public address.</p><p>The production environment was handled separately from the application archive. The .env file contained the application&#39;s database connection string and other runtime configuration, so it was deliberately excluded from the source package. I transferred the environment file separately, downloaded it onto the EC2 instance, changed its ownership to the application user, and restricted its permissions:</p><pre>sudo chown ssm-user:ssm-user /opt/backend-app/.env<br>sudo chmod 600 /opt/backend-app/.env</pre><p>The resulting permissions were owner read/write only. This is a tiny filesystem detail, but it is worth documenting because a production environment file is not ordinary application source code. The temporary S3 deployment bucket also received a narrowly scoped IAM permission allowing the EC2 role to retrieve the deployment objects. That permission was intended only for the transfer process and was not meant to become a permanent privilege for the application server.</p><p>With the application server prepared, I created the PostgreSQL layer using Amazon RDS. First I created a DB subnet group containing the two private subnets, one in each Availability Zone. The subnet group tells RDS which network locations it is allowed to use for the database instance. I then created a separate security group for PostgreSQL. Its only inbound application rule allowed TCP 5432 from the EC2 application&#39;s security group. I did not allow the database security group to accept traffic from 0.0.0.0/0; there was simply no reason for the database to have a public ingress path.</p><p>The RDS instance itself was created as PostgreSQL 17.9 using a db.t3.micro class with 20 GiB of encrypted gp3 storage. Public accessibility was explicitly disabled, and automated backups were configured with seven days of retention. The database was named backend_app and the master user was app_admin. RDS therefore provided the database engine and operational layer while the VPC and security groups controlled its network exposure. Once the instance reached available, I used its private RDS endpoint as the application&#39;s database host. One small lesson worth preserving here: <strong>don&#39;t trust yourself to copy a long AWS-generated endpoint from memory.</strong> I initially had the wrong hostname while troubleshooting and had to verify the actual RDS endpoint before continuing.</p><p>The application configuration was then supplied through DATABASE_URL. Rather than putting that value into the source archive, I generated the production environment file separately and transferred it to the EC2 instance. Once the environment was available, Prisma could finally use the production database configuration. I generated the Prisma client from the server&#39;s installed dependencies:</p><pre>cd /opt/backend-app<br>npx prisma generate</pre><p>The existing migration history was already part of the application deployment, so I applied it to the newly created, initially empty RDS database:</p><pre>npx prisma migrate deploy</pre><p>The migration completed successfully and created the application’s database schema. I then used Prisma’s database introspection to verify that the database actually contained the expected tables and relationships rather than assuming that a successful migration command meant everything was perfect:</p><pre>npx prisma db pull</pre><p>After introspection, I generated the Prisma client once more:</p><pre>npx prisma generate</pre><p>At this point the database was no longer an abstract AWS resource sitting in a console. The actual application’s schema existed inside it, Prisma could understand that schema, and the private EC2 instance had the credentials required to communicate with it. The next challenge was making the Node.js process behave like a real service rather than something I had to manually launch every time I opened a Session Manager shell.</p><p>I didn’t want the backend process to depend on an interactive Session Manager shell. Running node app.js manually would work, but it would also mean that the application disappears when the process exits and requires me to remember to start it again after a reboot. I therefore created a systemd service at /etc/systemd/system/backend-app.service. The service runs the application as ssm-user, uses /opt/backend-app as its working directory, starts /usr/bin/node /opt/backend-app/app.js, and is configured with Restart=always and a short restart delay. I also set NODE_ENV=production at the service level.</p><p>The service was then registered and enabled with:</p><pre>sudo systemctl daemon-reload<br>sudo systemctl enable backend-app</pre><p>I started it with:</p><pre>sudo systemctl start backend-app</pre><p>and verified its state with:</p><pre>sudo systemctl status backend-app</pre><p>The service came up successfully and the application logged that it was listening on port 4000. I also verified the listening socket directly from the operating system rather than relying only on the application log:</p><pre>sudo ss -lntp | grep &#39;:{port}&#39;</pre><p>The result showed Node listening on *:4000. This was an important checkpoint because it isolated the application layer from the AWS load-balancing layer: before involving an ALB, I knew the Node process was alive, running under the intended user, loading its production environment, and listening for connections on the expected application port. From this point onward, if something failed externally, I had a known-good backend to troubleshoot against.</p><p>The backend was healthy inside the private subnet, so I created the public entry point: an internet-facing Application Load Balancer. The ALB was placed across both public subnets, one in each Availability Zone, and received its own security group. Its inbound policy allowed HTTP traffic from the internet. The EC2 security group, meanwhile, was updated to allow the application’s traffic only from the ALB security group. This distinction is important: the EC2 instance was still not publicly exposed. The ALB became the only internet-facing component of the application path, while the private server continued to receive traffic through an explicitly trusted security-group relationship.</p><p>I then created a target group for the backend, using the EC2 instance as the target and configuring the target group to forward HTTP traffic to the application’s listening port. The health check was configured to request the backend’s / endpoint and consider an HTTP 200 response healthy. I registered the EC2 instance with the target group and created an HTTP listener on the ALB that forwards incoming requests to that target group. Initially, the target appeared as RegistrationInProgress, which was expected while AWS performed its health checks. After the checks completed, it transitioned to healthy. That gave me the final piece of the request path: a public ALB could accept a request, forward it through the private network to the EC2 instance, and receive a valid response from the Node.js application.</p><p>I then tested the complete path externally using curl. The request returned HTTP/1.1 200 OK, and the application returned the request headers it had received. Among those headers were the load balancer&#39;s forwarding headers, including x-forwarded-for, x-forwarded-proto, and x-forwarded-port. That was useful evidence beyond simply seeing a 200: it showed that the request had actually passed through the ALB before reaching Express. At this point the basic infrastructure path was working exactly as designed:</p><pre>Internet<br>   │<br>   ▼<br>Application Load Balancer<br>   │<br>   │  ALB security group<br>   ▼<br>Private EC2<br>   │<br>   │  EC2 security group<br>   ▼<br>Private PostgreSQL RDS</pre><p>The important thing was that every layer had a defined responsibility. The ALB handled public ingress and health checking, EC2 handled the application, RDS handled persistence, security groups controlled the allowed communication paths, and Systems Manager gave me administrative access without turning the application server into a public machine. I had finally reached the point where the infrastructure was no longer just a collection of successfully created AWS resources — it was a functioning end-to-end system.</p><p>With the complete network path working, I moved from infrastructure testing to an actual application endpoint. This was the point where the deployment stopped being a networking exercise and started being a real application test. The request reached the backend successfully, but instead of returning the expected API response, Prisma threw a database access error involving model.findFirst(). The wording made it initially look like a credentials or PostgreSQL permission problem. That was plausible enough to investigate, but I didn&#39;t want to start changing the database user or security groups without evidence. The database had already been successfully migrated and introspected, so the first question was whether the running application was actually using the database configuration I thought it was using.</p><p>I connected to the EC2 instance through Session Manager and inspected the runtime database configuration without printing the password. I parsed the DATABASE_URL and verified that the application was using the expected PostgreSQL username, the correct RDS hostname, the expected database name, and the PostgreSQL port. Everything looked correct. That ruled out one of the most boring but common explanations: the application wasn&#39;t accidentally pointing at an old database or using the wrong credentials. The next step was to bypass Prisma entirely and test the database connection using the same PostgreSQL driver available to the application.</p><p>I ran a direct pg connection from the application directory:</p><pre>cd /opt/backend-app &amp;&amp; \<br>node -e &#39;require(&quot;dotenv&quot;).config(); const { Client } = require(&quot;pg&quot;); const c = new Client({connectionString:process.env.DATABASE_URL}); c.connect().then(()=&gt;c.query(&quot;SELECT current_user, current_database()&quot;)).then(r=&gt;console.log(r.rows[0])).catch(e=&gt;console.error(e.message)).finally(()=&gt;c.end())&#39;</pre><p>The result was the first genuinely useful clue:</p><pre>no pg_hba.conf entry for host &quot;10.0.132.51&quot;,<br>user &quot;backend_admin&quot;,<br>database &quot;backend_app&quot;,<br>no encryption</pre><p>The wording looks like PostgreSQL itself was rejecting the user, but the final words, <strong>&quot;no encryption”,</strong>were the important part. The connection was reaching RDS, but it was attempting a non-SSL connection. RDS PostgreSQL was requiring an encrypted connection, so this wasn&#39;t actually a case of the username or password being wrong. The server was effectively saying, “I know who you are, but you&#39;re knocking on the wrong door.”</p><p>I repeated the same test with SSL explicitly enabled:</p><pre>new Client({<br>  connectionString: process.env.DATABASE_URL,<br>  ssl: {<br>    rejectUnauthorized: false<br>  }<br>})</pre><p>This time the connection succeeded and PostgreSQL returned:</p><pre>current_user: backend_admin<br>current_database: backend_app</pre><p>That was the turning point. The credentials were valid. The network path was valid. The RDS instance was accepting the connection. PostgreSQL itself worked. The failure was specifically related to how the application’s PostgreSQL connection was being established.</p><p>The remaining question was therefore not <strong>“Why can’t AWS reach my database?”</strong> but <strong>“Why is Prisma’s runtime adapter creating a connection differently from the successful test?”</strong> I inspected the project’s Prisma configuration and found that the application was using Prisma 7’s PrismaPg adapter from @prisma/adapter-pg, with the database connection string passed directly into the adapter. The Prisma CLI had successfully generated the client, deployed the migrations, and introspected the database, which initially made the situation confusing. But the runtime adapter was ultimately the important distinction: the application was using the Node PostgreSQL driver through PrismaPg, and that connection needed SSL configured explicitly.</p><p>The fix was fortunately small. I changed the PrismaPg adapter configuration so that the runtime PostgreSQL connection explicitly used SSL:</p><pre>const adapter = new PrismaPg({<br>  connectionString: process.env.DATABASE_URL,<br>  ssl: {<br>    rejectUnauthorized: false<br>  }<br>});</pre><pre>const prisma = new PrismaClient({<br>  adapter<br>});</pre><p>The important part was not changing the database credentials, recreating the RDS instance, opening additional security-group rules, or modifying PostgreSQL permissions. The infrastructure was already doing exactly what it was supposed to do. The application simply needed to establish its PostgreSQL connection using encryption. This was a useful reminder that “database access denied” is not necessarily a database authorization problem. Sometimes the database is rejecting the <em>connection characteristics</em> before authorization can even become the interesting part.</p><p>After changing the Prisma configuration, I restarted the systemd service rather than running the application manually:</p><pre>sudo systemctl restart backend-app</pre><p>I immediately verified that systemd considered the service healthy:</p><pre>sudo systemctl is-active backen-app</pre><p>The result was:</p><pre>active</pre><p>That only proved that Node had started successfully, though. A process being alive is a remarkably low bar for an API, especially one that has just spent several minutes arguing with PostgreSQL. I therefore repeated the same API request that had previously produced the Prisma error. This time the request completed successfully. The backend could reach RDS through the private network, Prisma could establish its encrypted PostgreSQL connection, the database query executed, and the API returned its expected response.</p><p>At that point the complete request path had been exercised rather than merely inferred from AWS console statuses:</p><pre>Client<br>  ↓<br>Internet<br>  ↓<br>Application Load Balancer<br>  ↓<br>Private EC2 instance<br>  ↓<br>Node.js / Express<br>  ↓<br>PrismaPg<br>  ↓<br>TLS-encrypted PostgreSQL connection<br>  ↓<br>Private RDS PostgreSQL</pre><p>That was the moment the deployment became a functioning application environment rather than a collection of AWS resources that happened to be green in the console. The ALB could reach the EC2 instance, EC2 could reach RDS, the application process could start under systemd, the Prisma client could communicate with PostgreSQL, and the API could actually perform database-backed work.</p><p>There was also a useful security lesson hidden inside the deployment process. I had created a temporary S3 bucket specifically to move the application archive and production environment file onto the private EC2 instance. Because the EC2 instance needed to download those objects, I temporarily attached an inline S3 policy to its IAM role allowing s3:GetObject only against that deployment bucket. That was intentionally scoped to the deployment artifact rather than granting the instance broad S3 access.</p><p>Once the transfer and deployment work was completely finished, that temporary permission needed to disappear. The same applied to the deployment objects themselves. The cleanup commands were:</p><pre>aws s3 rm s3://backend-app-deploy-123456789/backend-app.tar.gz</pre><pre>aws s3 rm s3://backend-app-deploy-1234567890/backend-app-production.env</pre><pre>aws s3api delete-bucket \<br>  --bucket backend-app-deploy-1234567890 \<br>  --region af-south-1</pre><pre>aws iam delete-role-policy \<br>  --role-name backend-app-ec2-ssm-role \<br>  --policy-name TemporaryDeploymentS3Read</pre><p>The order matters conceptually even if the commands themselves are straightforward: remove the temporary artifacts, remove the temporary deployment bucket, and then remove the temporary IAM permission that existed solely to facilitate that transfer. In particular, the production environment file was never meant to become a permanent deployment artifact in S3. It was a transport mechanism, not configuration storage.</p><p>With that, the environment had reached the shape I originally wanted: a public Application Load Balancer as the controlled entry point, an EC2 application server with no public IP, private PostgreSQL on RDS, private AWS service access through VPC endpoints where appropriate, Session Manager for administrative access instead of exposing SSH, and application-to-database traffic staying inside the VPC. The deployment had started with an empty AWS environment and ended with an actual database-backed Node.js application reachable through the ALB.</p><p>And, naturally, the thing that almost ruined the victory lap was not the VPC, the subnets, the NAT gateway, the load balancer, the private EC2 instance, RDS, systemd, or even Prisma migrations. It was one missing ssl property.</p><h3>Post-Deployment Cleanup and Hardening</h3><p>Getting the API working was the main milestone, but I didn’t want to confuse “it works” with “it’s finished.” There were still temporary deployment resources and permissions that existed only because I needed a practical way to get the application onto the private EC2 instance. Those are useful during provisioning and undesirable afterward. Infrastructure has a funny habit of accumulating little temporary things that become permanent simply because nobody remembers why they exist.</p><p>The first temporary component was the S3 deployment bucket. I had used backend-app-deploy-1234567890 as a controlled transport mechanism for the application archive and production environment file. The archive had deliberately excluded node_modules, .git, .env, and other environment-specific files:</p><pre>tar \<br>  --exclude=node_modules \<br>  --exclude=.git \<br>  --exclude=.env \<br>  --exclude=&#39;.env.*&#39; \<br>  -czf /tmp/backend-app.tar.gz .</pre><p>The production environment file was transferred separately and uploaded with server-side encryption:</p><pre>aws s3 cp \<br>  ~/backend-app-production.env \<br>  s3://backend-app-deploy-475309741540/backend-app-production.env \<br>  --sse AES256</pre><p>That distinction was deliberate. The source archive was treated as deployable application code, while the environment file contained production secrets and therefore needed to be handled separately. Once the EC2 instance had received the required files, there was no reason for those deployment artifacts to remain sitting in a temporary bucket.</p><p>The EC2 instance itself also had a temporary IAM capability specifically for this transfer. Its permanent role was primarily there for Systems Manager access through AmazonSSMManagedInstanceCore. I temporarily added an inline policy called TemporaryDeploymentS3Read that allowed s3:GetObject against the deployment bucket. The useful part of that policy was its narrow resource scope:</p><pre>{<br>  &quot;Effect&quot;: &quot;Allow&quot;,<br>  &quot;Action&quot;: &quot;s3:GetObject&quot;,<br>  &quot;Resource&quot;: &quot;arn:aws:s3:::backend-app-deploy-1234567890/*&quot;<br>}</pre><p>Once deployment was complete, that permission became unnecessary. Removing temporary permissions is just as important as adding them. Otherwise, six months later, someone sees an EC2 role with S3 access and has to reverse-engineer whether it is genuinely required or whether it is another fossil from deployment day.</p><p>Another deliberate choice was leaving SSH closed on the application server. The EC2 instance had no public IP and no inbound rule allowing arbitrary administrative access. Instead, Session Manager provided the management path through the private VPC. This meant I could connect to the instance without opening an SSH port to the internet and without making the private application server publicly addressable.</p><p>The application security group followed the same principle. It initially had no inbound application traffic at all. Once the ALB existed, I added exactly one application ingress path: TCP 4000 from the ALB security group. The EC2 instance therefore did not need to trust the entire internet; it only needed to trust the component that was supposed to send application traffic to it.</p><p>The database was even more restrictive. RDS PostgreSQL accepted TCP 5432 only from the application security group. There was no public accessibility and no rule allowing arbitrary external clients. The resulting security-group relationship was effectively:</p><pre>Internet<br>   │<br>   ▼<br>ALB security group<br>   │<br>   │ TCP 80<br>   ▼<br>EC2 application security group<br>   │<br>   │ TCP 4000<br>   ▼<br>Node.js application<br>   │<br>   │ TCP 5432 + SSL<br>   ▼<br>RDS security group</pre><p>This was one of the more satisfying parts of the deployment because the security model became understandable simply by looking at the relationships between security groups. The ALB was public because it had to be. The application server was private because it didn’t. The database was even more private because it definitely didn’t need to know what the internet was doing.</p><p>There were still a few things I would classify as future hardening rather than prerequisites for this deployment: HTTPS on the ALB, proper secret management instead of transporting an environment file during deployment, tighter production CORS configuration, application-level health checks, centralized logging and monitoring, and eventually a more automated deployment mechanism. None of those were necessary to prove that the core architecture worked, but they are the obvious next layer once this environment moves beyond a manually provisioned UAT deployment.</p><p>The important distinction is that these are improvements to an already functioning architecture, not evidence that the architecture was incomplete. The fundamental separation was already there. The next stage is reducing the number of things I have to remember to do manually.</p><h3>The Final Architecture Record</h3><p>At the end of the deployment, the AWS environment consisted of one custom VPC using 10.0.0.0/16, split across public and private subnets in two Availability Zones. The public subnets existed primarily for the internet-facing Application Load Balancer and NAT infrastructure. The application EC2 instance lived in a private subnet, while RDS PostgreSQL occupied the private database layer through its own subnet group.</p><p>The public side used an Internet Gateway for internet connectivity. Private application resources used the NAT Gateway for outbound internet access when necessary, while the S3 Gateway Endpoint provided private S3 access without requiring application traffic to traverse the public internet. Systems Manager used interface VPC endpoints so that Session Manager could operate without giving the EC2 instance a public address.</p><p>The application server was an Amazon Linux 2023 t3.micro instance named backend-app-app-01. It ran the Node.js/Express backend from /opt/backend-app under the ssm-user account. The application itself listened on TCP 4000, while systemd managed its lifecycle and automatically restarted the process if it exited.</p><p>The systemd unit was intentionally simple:</p><pre>[Unit]<br>Description=Backend ManaAppgement Backend<br>After=network.target</pre><pre>[Service]<br>Type=simple<br>User=ssm-user<br>WorkingDirectory=/opt/backend-app<br>ExecStart=/usr/bin/node /opt/backend-app/app.js<br>Restart=always<br>RestartSec=5<br>Environment=NODE_ENV=production</pre><pre>[Install]<br>WantedBy=multi-user.target</pre><p>This was preferable to leaving a terminal session running node app.js and pretending that counted as production process management. If the machine rebooted, systemd could bring the service back. If Node crashed, systemd could restart it. The application therefore had an actual operating-system service boundary rather than depending on somebody remembering which shell session contained the backend.</p><p>The database layer was a private PostgreSQL 17.9 RDS instance named backend-app-postgres. It used a dedicated DB subnet group spanning the two private subnets, encryption at rest, automated backups with a seven-day retention period, and a dedicated security group. The database was explicitly configured as not publicly accessible.</p><p>Prisma 7 was used with @prisma/adapter-pg rather than relying on the older connection style. The application generated its Prisma client during deployment and applied the existing migrations using:</p><pre>npx prisma generate</pre><p>followed by:</p><pre>npx prisma migrate deploy</pre><p>I also used:</p><pre>npx prisma db pull</pre><p>as a useful verification step. That confirmed that Prisma could connect to the production database and inspect the schema, while also giving me a concrete list of the models that actually existed in the deployed database.</p><p>The final public entry point was an internet-facing Application Load Balancer named backend-app-alb. Its listener accepted HTTP traffic and forwarded requests to the backend-app-tg target group on the application&#39;s port 4000. The target group used the EC2 instance as its target and performed an HTTP health check against /. Once the application was running correctly, the target transitioned from RegistrationInProgress to healthy.</p><p>The end-to-end test was deliberately performed from outside the private network. A request to the ALB returned HTTP/1.1 200 OK, and the backend response exposed the forwarded request headers, including x-forwarded-for, x-forwarded-proto, and x-forwarded-port. That confirmed that the request wasn&#39;t merely reaching the load balancer; it was actually traversing the load balancer and arriving at the Express application.</p><p>The resulting architecture was therefore:</p><pre>INTERNET<br>                        │<br>                        ▼<br>              ┌─────────────────┐<br>              │ Application     │<br>              │ Load Balancer   │<br>              └────────┬────────┘<br>                       │<br>                  HTTP :4000<br>                       │<br>                       ▼<br>              ┌─────────────────┐<br>              │ Private EC2     │<br>              │ Node/Express    │<br>              │ systemd         │<br>              └────────┬────────┘<br>                       │<br>                  PostgreSQL<br>                    + SSL<br>                       │<br>                       ▼<br>              ┌─────────────────┐<br>              │ Private RDS     │<br>              │ PostgreSQL      │<br>              └─────────────────┘</pre><p>That diagram is the short version. The actual AWS implementation also included the VPC routing layer, NAT Gateway, S3 Gateway Endpoint, Systems Manager interface endpoints, security groups, IAM role, RDS subnet group, private subnets, public subnets, and the associated route tables. The important thing is that every one of those pieces had a specific reason to exist. None of them were added simply because AWS had a checkbox for it.</p><p>The biggest practical lesson from the deployment was that infrastructure problems rarely announce themselves with the exact component responsible. The final Prisma failure was a perfect example. The API said database access was denied. The database was reachable. The credentials were correct. The migrations had worked. The problem was ultimately the encryption mode used by the runtime PostgreSQL connection. The successful fix came from reducing the problem layer by layer rather than randomly changing AWS configuration until something stopped complaining.</p><p>And that is probably the most useful thing to preserve from this entire deployment: not just the final architecture, but the path taken to prove each layer worked.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=97ca138f4b3b" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Deploying app]]></title>
            <link>https://medium.com/@claudwatari/deploying-ng-app-to-droplet-7f599ada75ca?source=rss-bc9a15dfa479------2</link>
            <guid isPermaLink="false">https://medium.com/p/7f599ada75ca</guid>
            <category><![CDATA[deployment]]></category>
            <category><![CDATA[ubuntu]]></category>
            <category><![CDATA[ssh]]></category>
            <dc:creator><![CDATA[Claud Watari]]></dc:creator>
            <pubDate>Mon, 22 Sep 2025 15:35:09 GMT</pubDate>
            <atom:updated>2025-09-23T11:55:46.520Z</atom:updated>
            <content:encoded><![CDATA[<p>For future reference, follow the steps below (ubuntu):</p><p><em>Generate an ssh key:</em></p><blockquote>— <strong><em>ssh-keygen -t ed25519 -C “</em></strong><a href="/service/mailto:your_email@example.com"><strong><em>your_email@example.com</em></strong></a><strong><em>”</em></strong></blockquote><p>copy the file content:</p><blockquote><strong><em>— cat ~/.ssh/id_ed25519.pub</em></strong></blockquote><p>ssh into the instance: (you can use the droplet console)</p><blockquote><strong>eg : ssh -i ~/.ssh/id_ed25519 your_user@your_ip</strong></blockquote><p>Update the authorized keys:</p><blockquote><strong>— nano ~/.ssh/authorized_keys</strong></blockquote><p>Paste the ssh key in authorized keys.</p><p>Log In to the instance from your pc (also from the droplet is fine).</p><p>Install nginx</p><blockquote><strong><em>sudo apt update<br>sudo apt install nginx</em></strong></blockquote><p>Create config file for nginx:</p><blockquote><strong><em>sudo nano /etc/nginx/sites-available/&lt;your-app&gt;</em></strong></blockquote><p>Edit file as below:</p><blockquote><strong><em>server {<br> listen 443 ssl;<br> server_name yourdomain.com </em></strong><a href="http://www.settlement-uatfms.resilientcloud.co/"><strong><em>www.</em></strong></a><strong><em>yourdomain.com;</em></strong></blockquote><blockquote><strong><em>root /var/www/{your_parent_directory};<br> index index.html;</em></strong></blockquote><blockquote><strong><em>ssl_certificate /etc/letsencrypt/live/yourdomain.com/fullchain.pem;<br> ssl_certificate_key /etc/letsencrypt/live/yourdomain.com/privkey.pem;<br> include /etc/letsencrypt/options-ssl-nginx.conf;<br> ssl_dhparam /etc/letsencrypt/ssl-dhparams.pem;<br> <br> location / {<br> try_files $uri /index.html;<br> }</em></strong></blockquote><blockquote><strong><em>error_page 404 /index.html;</em></strong></blockquote><blockquote><strong><em># if you need to proxy other paths<br> location /your path{<br> proxy_pass </em></strong><a href="http://localhost:5000/"><strong><em>http://localhost:</em></strong></a><strong><em>{port_number}; <br> proxy_http_version 1.1;<br> proxy_set_header Upgrade $http_upgrade;<br> proxy_set_header Connection ‘upgrade’;<br> proxy_set_header Host $host;<br> proxy_cache_bypass $http_upgrade;<br> }<br>}</em></strong></blockquote><p>Create a symlink in “/sites-enabled” to enable the site:</p><p><strong>sudo ln -s /etc/nginx/sites-available/&lt;your-app&gt;/etc/nginx/sites-enabled/</strong></p><p>Confirm nginx config is fine:</p><blockquote><strong><em>sudo nginx -t</em></strong></blockquote><p>Restart nginx:</p><blockquote><strong><em>sudo systemctl restart nginx</em></strong></blockquote><p>Access your app.</p><p>FURTHER READING</p><p>If you need to update or create new ssl certificates (I’ll be using let’s encrypt for this example):</p><blockquote><strong><em>sudo apt update<br>sudo apt install certbot python3-certbot-nginx</em></strong></blockquote><blockquote><strong><em>sudo certbot — — nginx -d yourdomain.com -d </em></strong><a href="http://www.example.com/"><strong><em>www.yourdomain.com</em></strong></a></blockquote><p>Verify:</p><blockquote><strong><em>sudo nginx -t</em></strong></blockquote><p>Restart nginx</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=7f599ada75ca" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[How to write understandable commit messages]]></title>
            <link>https://medium.com/@claudwatari/how-to-write-understandable-commit-messages-071cb6829930?source=rss-bc9a15dfa479------2</link>
            <guid isPermaLink="false">https://medium.com/p/071cb6829930</guid>
            <dc:creator><![CDATA[Claud Watari]]></dc:creator>
            <pubDate>Tue, 03 Jun 2025 08:07:57 GMT</pubDate>
            <atom:updated>2025-06-03T08:07:57.808Z</atom:updated>
            <content:encoded><![CDATA[<p>When typing a commit messages for your committed changes:</p><p>Describe what kind of changes you made for example:<br>Did you make a feature? Fixed a bug? Upgraded performance?</p><p>Here’s a simple guide to make your commit messages more readable and meaningful.</p><h3>1. Describe the Type of Change</h3><p>Before writing your message, think about what kind of change you made. Was it a new feature? A bug fix? A minor tweak?</p><p>Use a clear prefix to label your commit. Here are some common ones:</p><h3>✅ FEAT: — New Feature</h3><p>Use this when you add a new feature or functionality.<br> <strong>Example:</strong><br> FEAT: add user login form</p><h3>🐛 BUG: — Bug Fix</h3><p>Use this when you fix a specific bug or error in the code.<br> <strong>Example:</strong><br> BUG: fix crash when clicking submit without input</p><h3>🔧 FIX: — Minor Fix or Adjustment</h3><p>Use this for small fixes that aren’t full bugs — maybe a typo, layout tweak, or logic correction.<br> <strong>Example:</strong><br> FIX: correct typo in dashboard title</p><h3>🧹 CHORE: — Maintenance or Cleanup</h3><p>Use this for tasks that don’t affect functionality, like refactoring code, updating dependencies, or cleaning files.<br> <strong>Example:</strong><br> CHORE: remove unused variables and console logs</p><h3>2. Keep the Message Short and Clear</h3><p>After the prefix, write a short, specific message describing what changed. Try to answer the question: <strong>“What did I do?”</strong></p><h3>Final Tip: Be Consistent</h3><p>Use the same format across all commits. It makes scanning history easier and improves collaboration.</p><p>Happy committing! 💻✨</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=071cb6829930" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Run Containerized Applications Without “containers” (docker etc)]]></title>
            <link>https://medium.com/@claudwatari/run-containerized-applications-without-containers-docker-etc-8d15e11656ee?source=rss-bc9a15dfa479------2</link>
            <guid isPermaLink="false">https://medium.com/p/8d15e11656ee</guid>
            <category><![CDATA[docker]]></category>
            <category><![CDATA[microservices]]></category>
            <dc:creator><![CDATA[Claud Watari]]></dc:creator>
            <pubDate>Tue, 02 Jul 2024 00:09:17 GMT</pubDate>
            <atom:updated>2024-07-02T00:17:43.549Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/200/1*_gDU9Q9oOF4pRnx1zyOPTg.jpeg" /><figcaption>we_love_code</figcaption></figure><p>For future reference, applications built using say, docker, can be run without necessarily having docker.</p><p>Open a terminal in the respective directories, eg: frontend and backend.</p><p>Run app as you normally would.</p><p>For example, start a python app as normally would.</p><p>I prefer to use ubuntu, even on windows. You can download this from the Microsoft store, and set up WSL.</p><p>In your wsl terminal, cd into the directory eg:<strong><em> cd /mnt/c/Users/HomePC/Documents/myProject</em></strong>, or whichever path your project is on.</p><p>Run your npm or pip or whatever installations and start the apps individually.</p><p>To install python packages at once, run <strong>pip install -r requirements.txt</strong> which installs all packages, just like <strong>npm install</strong> with package.json.</p><p>Using this solution because I found myself in a bind in regards to hardware performance. My laptop fan started whirring loudly as soon as I started Docker Desktop, so I decided to run them (the apps) individually.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=8d15e11656ee" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[My experience in Bootcamp so far]]></title>
            <link>https://medium.com/@claudwatari/my-experience-in-bootcamp-so-far-6d0679bcffbd?source=rss-bc9a15dfa479------2</link>
            <guid isPermaLink="false">https://medium.com/p/6d0679bcffbd</guid>
            <category><![CDATA[andela]]></category>
            <dc:creator><![CDATA[Claud Watari]]></dc:creator>
            <pubDate>Thu, 16 May 2019 17:31:03 GMT</pubDate>
            <atom:updated>2019-05-17T05:16:35.372Z</atom:updated>
            <content:encoded><![CDATA[<p>It has been a whole week now since I started bootcamp. Having attended the pre-bootcamp workshop, I felt a little prepared in the beginning. This did not help much to calm my anxiety. I was happy though to meet one Andelan developer who allowed us to feel welcome. A week of intense learning followed. Having crashed my old machine, and not made much progress with the challenge 2, I felt doomed. Pre-bootcamp enabled me to familiarize myself with the culture of Andela bootcamps. I was glad there were friendly people whom I could ask for help.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/203/1*qbBSYeQeVhrB6OGqe27a-A.jpeg" /></figure><p>Learning and implementing followed. Concepts I have before never learnt, let alone understood lay before my mind. Starting out, I would spend most of my nights awake, trying to catch up and make progress. It reached a point where my host exclaimed in awe at my lack of sleep. People retired to bed and left me working, and would wake up to find me in the same position — with a cup of tea.</p><p>Soon, a few friends from bootcamp invited me for collaboration and problem solving. I spent several days away from my hosts’ home, with people who I knew would help me better myself. Endless nights of coding followed. Sitting at the table, we would discuss until surprise, dawn was upon us. On the third day, it became something natural, to stay awake overnight, and on one meal a day, generally.</p><p>But the passion drove us, kept us going. When at last I felt I could not carry on any longer, I slumped. For a whole hour and a half in four days, I managed to convince my mind to let me sleep — although I woke up feeling worse. I wished I hadn’t even slept.</p><p>But work abounded. No rest. In the midst of this, I lost my phone, the day before the first day of bootcamp. To make matters complicated, the venue was changed for the first two days. Needless to say, I ended up not attending the first day of bootcamp. No phone to ask for clarification. I went to the original venue to ask for help. I t was here that I was able to receive information on the new venue. This aided by the bootcamp’s Learning Facilitator.</p><p>If you know me, you know I don’t live without my phone. But this was no time to focus on such trivialities — I was already too beat to feel bothered.</p><p>Sleepless nights continued, and restless days to boot. The apocalypse was nigh for me. Try going to bed, a failed feature keeps me awake until I go back to my machine.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/391/1*wsZ_GEQPDYhf0p9YBOVZ-w.png" /></figure><p>The week went by, with daily reviews — twice a day actually. Even challenge 1 still needed correction — at a time when I felt I needed no further distraction.</p><p>Truth be told, I was at the verge of giving up. At some point, I explained to my colleagues that if it were not for my lost phone, I would have bought a ticket back home. And no shocker, they felt disappointed.</p><p>I have never felt so defeated in my life, but thank goodness, my passion is so strong, I pushed on. After all, nothing good comes easy.</p><p>Three days into the bootcamp, I was finally able to lay down for six hours. I felt accomplished for this. If I could relax a time like this, then it is true that apostle Peter also slept on the night before his execution.</p><p>But all through, I had a very reliable team of people. From fellow bootcampers to my Learning Facilitator Assistant to the Learning Facilitator — I would not have been here if it were not for them. This showed me the true Andelan spirit of empathy in reality. I felt stocked and anxious to be a part of this wonderful family. Reality though, spoke a different language, painted a different picture.</p><p>At the time of writing this article, it is four days into bootcamp.</p><p>Project presentations are the day following this, and anxiety and defeat persist. But my Learning Facilitator has been wonderful, even advising me to be asleep before midnight. I wish I could do it though.</p><p>Today of all days, sleep is a luxury I can only imagine as the reserve of others. The time of reckoning is here — and I’m half-way done.</p><p>Whoever has been praying for me will have to keep watch with me.</p><p>I cannot wait for the next 24 hours to pass, come what may.</p><p>I want to know my fate.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1000/1*QkVWsvg6EdY6YnHhzDUcNw.jpeg" /></figure><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=6d0679bcffbd" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[An Interesting Tool/Technology I Encountered In Preparation For Bootcamp]]></title>
            <link>https://medium.com/@claudwatari/an-interesting-tool-technology-i-encountered-in-preparation-for-bootcamp-d0c812abca64?source=rss-bc9a15dfa479------2</link>
            <guid isPermaLink="false">https://medium.com/p/d0c812abca64</guid>
            <category><![CDATA[andela]]></category>
            <dc:creator><![CDATA[Claud Watari]]></dc:creator>
            <pubDate>Wed, 15 May 2019 16:20:13 GMT</pubDate>
            <atom:updated>2019-05-15T16:20:13.560Z</atom:updated>
            <content:encoded><![CDATA[<p>When I started working on the bootcamp project, I had only before worked with PHP for backend. Then here comes a required stack I have never interacted with. Ahead lay a long path, of learning and implementing.</p><p>Even in my previous projects, I only ever used database queries, nothing too complex. For the bootcamp, the rule was that we were not to use databases. Instead, we had to use data structures to handle information. Now this was a whole new level of new for me. The fact that I was working against time only worked to complicate matters from my point. But in the Andelan spirit of passion, nothing was going to deter my resolve to complete the challenge.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/300/1*0ebVEx1itwOsB-p8OEwFDw.jpeg" /></figure><p>A period of self improvement followed. Working on the first challenge, which was designing the app, was a walk in the park. I wanted to finish as early as possible. I knew that challenge 2, creating the API endpoints, using new technology, was going to consume my time.</p><p>Not long after, I began working on my challenge 2. This called for exploring and learning. Every resource a student can lay their hands on, I sought.</p><p>The period that followed after, I learnt new ways to solve problems that not even campus had opened my eyes to. I knew the power of JavaScript for data handling, but had no experience with it for that.</p><p>Working with JavaScript for the project prompted me to elevate my mental capacities. New youtube channels I discovered, same as web development sites and tutorials. I even signed up for a few courses to hone my new knowledge as I worked at the same time on my challenge.</p><p>Around this time, I also stumbled upon the Andela Learning Community. Realizing that I was free to apply, I did not hesitate and signed up. This presented me a welcome opportunity to familiarize myself with the technologies needed.</p><p>What followed was a time in my life where I felt I am indeed making progress. I love learning about new technologies, and utilizing the knowledge in practical projects. So I was a very self-satisfied person, but I had a long way to go.</p><p>In the weeks that ensued, I learnt a whole lot of new stuff. Using javascript data structures to handle information, using memory for data storage. Wow, I did not even know data could be stored without a database.</p><p>This was exhilarating, but there was much to be done.</p><p>This was exhilarating, but there was much to be done.</p><p>Bootcamp week was upon us, and I was yet to complete my challenge. Nay, I had not implemented the required functionality.</p><p>But, I found teammates and fellow bootcampers who contributed a lot to my learning. In the Andelan spirit of collaboration, I was able to learn even more.</p><p>Implementing functionality using this new, magical language became easier, and concepts more understandable.</p><p>All in all, I have been a happy learner, and there is still more to learn. I look forward to joining the Andela Learning Community, so I can enlighten my mind.</p><p>Learning is fun, but applying the knowledge acquired is more useful, to memory and humanity.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*dRCaaqM7BAmwp7mk052nNA.jpeg" /></figure><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=d0c812abca64" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[My reflections on Andela’s EPIC values]]></title>
            <link>https://medium.com/@claudwatari/my-reflections-on-andelas-epic-values-c2abc348e33d?source=rss-bc9a15dfa479------2</link>
            <guid isPermaLink="false">https://medium.com/p/c2abc348e33d</guid>
            <category><![CDATA[andela]]></category>
            <dc:creator><![CDATA[Claud Watari]]></dc:creator>
            <pubDate>Tue, 14 May 2019 15:29:55 GMT</pubDate>
            <atom:updated>2019-05-15T09:17:21.750Z</atom:updated>
            <content:encoded><![CDATA[<h3>My Reflections On Andela’s EPIC Values</h3><p>When I first heard of EPIC values, I got intrigued and also in awe of what these EPIC values might mean. I heard the phrase Being Andelan is being epic and to me, this was one of those things that inside-people come up with . Though it didn’t sound as self glorifying as it would seem as you read.</p><p>Even so, I did learn , about what it means to be epic.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/247/1*A1M6mUcBIpPFIu8OzA3CGA.png" /><figcaption>what does being epic mean?</figcaption></figure><p>As I started delving into the Andela homestudy, I did come across this thing that I had heard of before — being epic.</p><p>With study and progress, I did come to realize, being epic is about being human, after all. Being empathetic.</p><p>As one Andelan mentor of mine put it,</p><blockquote>“ <em>Being Andelan is being epic and embodying empathy. Because we build products for people, we have to understand them</em>.”</blockquote><p>Then, I also learnt that EPIC was an acronym, and it does embody being epic.</p><p>Excellence, which calls for giving the best one can in whatever we are engaging in.</p><p>Passion, the driving force behind excellence. The innate drive to do better and see something to the end, because after all, it is the life of you.</p><p>Integrity, the idea that great people can be trusted to do the right thing, out of their own will. Even when your values are under test it is integrity that pushes you to stand your ground.</p><p>Collaboration. This is the key that builds trustworthiness and mutual trust in whatever endeavor. Andela values a team player, someone of integrity that can be trusted to work with team members towards the accomplishment of a defined goal.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*5740IAsleFW8DxCFJSTIyQ.jpeg" /><figcaption>I am epic</figcaption></figure><p>Being in the Andela bootcamp, I have come to relate to, understand, and realize how important it is to follow these epic values.</p><p>Indeed, without these core values, nobody would care nor want to interact with you, because we all love epic people.</p><p>These values, that we all should strive to live by, will help us reach greater heights, even by help from other people, collaborators, so to say.</p><h3><strong><em>Be epic</em></strong></h3><blockquote>You have to be doing things that matter — responsibility, but also responsibility with epic and beautiful and noble tasks.</blockquote><blockquote>- Michelle Bachelet</blockquote><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=c2abc348e33d" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[How I demonstrated Growth Mindset recently]]></title>
            <link>https://medium.com/@claudwatari/how-i-demonstrated-growth-mindset-recently-fc83c963689e?source=rss-bc9a15dfa479------2</link>
            <guid isPermaLink="false">https://medium.com/p/fc83c963689e</guid>
            <category><![CDATA[andela]]></category>
            <dc:creator><![CDATA[Claud Watari]]></dc:creator>
            <pubDate>Tue, 14 May 2019 14:40:46 GMT</pubDate>
            <atom:updated>2019-05-14T14:40:46.513Z</atom:updated>
            <content:encoded><![CDATA[<p>Starting and working continuously on the Andela developer challenge has been an enlightening journey for me.</p><p>The challenge was given at a time when I had just learnt enough programming to have some sort of credibility in the developer world.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/225/1*li4ED1jj1GV5irRlE1IXOw.png" /><figcaption>Newbie programmer</figcaption></figure><p>After I started working on the challenge, with good design skills, completing the UI was as easy as the alphabet to a preschooler.</p><p>However, I got to challenge 2 (creating API endpoints) in a language I had no prior experience with — just coming green. Alas, this was a tune I was definitely not used to singing, made more complicated by the fact that I was working on a tight deadline.</p><p>Consequently, my life as a inso-maniac went into full-drive. Countless nights spent checking online resources to help my incapacities, I decided I was ready to get down to work and learn as I try to complete the challenge.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*doHmZeUhS5-DEOr1B6Q8Qg.jpeg" /></figure><p>Then came the time to meet fellow aspiring world class developers, and already accomplished world class developers at Andela. These were people whom I usually just saw online on articles and youtube videos. (Freak much, I even got a facebook badge for Andela’s fan follower). Now here the reality hit home. Shape up or ship out. I decided, tough people never die so no matter what I will keep going.</p><p>Meeting fellow bootcampers, some of whom were “no better than me” in completing the challenge, gave me some hope. This is cut-throat business, in my mind, and any slip knocks you off. But having interacted with the Andela home study curriculum, I knew that one of the core beliefs of being Andelan is demonstrating a growth mindset — a concept which explains that every one has the capacity to learn and better themselves — knowledge-wise and wisdom-wise.</p><p>So, with this in mind, I felt I was already well-poised for growth. The challenge can be done, in my mind, reality however offered no solution as to how it could be done.</p><p>Two days in, fellow bootcampers said “Hey Claud, we can help each other here, in the Andelan spirit of collaboration”. So since I landed at Andela, it has been constant team-work and effort to assist each other and collaborate in slaying our respective dragons.</p><p>On the start of bootcamp, we were assigned Learning Facilitation Assistants, fellow accomplished developers at Andela, who will be our “tour-guides”, people who will be with us every step of the way, people we can reach out to and collaborate with.</p><p>And so, from the first challenging task, it has been the growth mindset that has enabled me to come this far, by adapting to Andela’s core values of Excellence, Passion, Integrity and Collaboration.</p><p>And these same values will drive me, and other developers, even further.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Kg2vOHABRlhTCIRCoZ65zQ.jpeg" /></figure><p>Cycle of success — the Andela way</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=fc83c963689e" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>