DEV Community: Shaista Aman Khan

From COBOL to Cloud: How Kiro's Spec-Driven Development Transformed Legacy Modernization

Shaista Aman Khan — Mon, 10 Nov 2025 18:32:01 +0000

Building COBRA - a COBOL Banking Resilience Agent that parses legacy code and generates AWS infrastructure, powered by Kiro's systematic approach to AI-assisted development"

The Challenge: 60 Years of Banking Code

Banks worldwide run on billions of lines of COBOL code written decades ago. Complete rewrites are risky and expensive, yet modernization is essential. I set out to build COBRA (COBOL Banking Resilience Agent)—an AI system that analyzes legacy COBOL and generates modern AWS infrastructure.

The twist? I built it entirely with Kiro, and the experience completely changed how I approach complex software development.

What I Built

COBRA is an agentic AI orchestration system that:

Parses COBOL-85/2002 source code and generates Abstract Syntax Trees
Recognizes banking patterns (interest calculations, transaction posting, batch processing)
Generates production-ready AWS Lambda functions, API Gateway configs, and CDK infrastructure
Provides a React web interface for instant analysis
Integrates with Kiro via Model Context Protocol (MCP)

The result: 142 files, comprehensive documentation, and a zero-cost development architecture—all built systematically through Kiro's spec-driven workflow.

My Favorite Thing About Kiro: Spec-Driven Development That Actually Works

Before Kiro: The Chaos of "Just Start Coding"

My typical approach was:

Have a vague idea
Start coding immediately
Realize requirements are unclear
Refactor extensively
Lose track of what's done vs what's needed
Ship something that mostly works

For a complex project like COBRA (COBOL parser + logic analyzer + LLM integration + AWS generators + web interface), this approach would have been a disaster.

With Kiro: Systematic, Iterative, Traceable

Kiro introduced me to spec-driven development with three documents:

1. requirements.md - EARS-Compliant Requirements

## Requirement 1: COBOL Parsing

**User Story:** As a modernization engineer, I want to parse COBOL source files, 
so that I can analyze legacy banking systems.

#### Acceptance Criteria
1. WHEN a COBOL-85 source file is provided, THE System SHALL generate an AST 
   within 30 seconds for files up to 10,000 lines
2. WHILE parsing, THE System SHALL identify all data structures, procedures, 
   and file operations
3. IF parsing errors occur, THEN THE System SHALL provide line numbers and 
   actionable error messages

Every requirement was measurable, testable, and traceable.

design.md - Architecture Decisions

## Component: COBOL Parser

### Technology Choice: Custom TypeScript Parser
**Rationale:** Existing parsers (tree-sitter-cobol) lack banking-specific 
pattern recognition. Custom parser enables:
- Recognition of interest calculation patterns
- Extraction of transaction validation logic
- Support for multiple COBOL dialects

### Performance Strategy
- Three-tier caching (AST, Analysis, LLM responses)
- Worker thread pool for parallel processing
- Streaming parser for files >5000 lines

The design document became my contract—every implementation decision was documented and justified.

tasks.md - Actionable Implementation Plan

- [ ] 1. Build COBOL parser with AST generation
  - [ ] 1.1 Implement lexer for COBOL tokens
  - [ ] 1.2 Create parser for IDENTIFICATION, DATA, and PROCEDURE divisions
  - [ ] 1.3 Generate AST with source map for error reporting
  - _Requirements: 1.1, 1.2, 1.3_

- [ ] 2. Create logic analyzer for banking patterns
  - [ ] 2.1 Implement pattern recognizer for interest calculations
  - [ ] 2.2 Extract transaction validation rules
  - _Requirements: 2.1, 2.2_

Each task referenced specific requirements, making progress trackable and ensuring nothing was missed.

How This Changed My Development Approach

Upfront Clarity Eliminated Rework Old way: Build parser → Realize it doesn't handle CICS transactions → Refactor everything

Kiro way: Document requirement for CICS support in requirements.md → Design parser architecture to handle it → Implement once correctly

Impact: Reduced rework by ~70%. Most code worked on first implementation.

Steering Documents Made Kiro a Domain Expert I created 5 steering documents in .kiro/steering/:

banking-patterns.md (366 lines):

## Interest Accrual Pattern

**COBOL Code:**
cobol
COMPUTE INTEREST-AMOUNT = PRINCIPAL-BALANCE *
    (INTEREST-RATE / 100) * (DAYS-ELAPSED / 365).

Business Meaning: Simple interest calculation using actual/365 day-count convention, common in US banking. Division by 100 converts percentage to decimal.

AWS Translation: Lambda function with business logic, DynamoDB for state, EventBridge for scheduled daily accrual.


This transformed Kiro from "generic coding assistant" to "COBOL modernization expert."

**Without steering**: "This code multiplies three numbers"
**With steering**: "This calculates simple interest using actual/365 convention, requires overflow protection for balances >$999,999, and should include audit logging for compliance"

### 3. MCP Integration Created Seamless Workflows

I built COBRA as an MCP server with 5 tools:
- `parseCobol` - Parse COBOL and generate AST
- `analyzeLogic` - Extract banking patterns
- `generateSpec` - Create requirements/design/tasks
- `generateAWSCode` - Generate Lambda/CDK code
- `suggestModernization` - Recommend migration strategies

**The magic**: These tools maintain state and cache results.

**Example workflow:**

Me: "Analyze examples/interest-calculation.cbl"

Kiro: → Calls parseCobol (caches AST) → Calls analyzeLogic (uses cached AST, finds interest pattern) → Calls generateAWSCode (generates Lambda with exact business logic) → Creates files in my workspace → Shows architecture diagram

Time: <60 seconds Cost: $0.10 (with 80% cache hit rate on subsequent runs)

4. Hybrid Approach: Spec-Driven + Vibe Coding

I discovered the best approach combines both:

Spec-driven for architecture: Parser, analyzer, generators—these needed precision
Vibe coding for polish: "Make the header match the logo colors"—these needed rapid iteration

Example: Building the web interface

Spec-driven: Define React components, API endpoints, state management
Vibe coding: "Use navy/blue theme matching the logo"
Result: Solid architecture + beautiful UI

The Most Impressive Code Generation

The orchestrator system with performance optimizations blew my mind.

In one conversation, Kiro generated:

Complete orchestrator coordinating 5 components
Three-tier caching system with automatic key generation
Worker thread pool for parallel processing
Real-time cost tracking with provider-specific pricing
Progress tracking with callback system
Comprehensive error handling

What made it impressive: Kiro understood complex component interactions, implemented sophisticated caching achieving 80-95% hit rates, and met strict performance targets (10K lines in <30s) on first implementation.

Measurable Impact

Metric	Before Kiro	With Kiro	Improvement
Planning Time	0 hours (just started coding)	4 hours (requirements + design)	Better outcomes
Implementation Time	~40 hours (with extensive rework)	~20 hours (minimal rework)	2x faster
Code Quality	~60% worked first try	~90% worked first try	50% improvement
Documentation	Written after (if at all)	Built-in (the spec)	Always current
Collaboration	Tribal knowledge	Clear contract (spec docs)	Team-ready

Key Lessons Learned

1. AI Coding Isn't About Speed—It's About Systematic Thinking

Kiro didn't just help me code faster. It helped me think better by forcing me to:

Clarify requirements before implementation
Document architectural decisions
Break complex problems into manageable tasks
Track progress systematically

2. Domain Knowledge Multiplies AI Effectiveness

Generic prompts get generic results. Domain-specific steering documents (banking patterns, modernization strategies) transformed Kiro into a subject matter expert.

Investment: 4 hours writing steering docs
Return: Every subsequent conversation was 10x more productive

3. Spec-Driven Development Scales

For COBRA's complexity (142 files, 11 major features), spec-driven development was essential. The spec became:

My roadmap (tasks.md)
My documentation (requirements.md + design.md)
My quality assurance (acceptance criteria)
My collaboration tool (clear contract)

4. The Best Approach Is Hybrid

Rigid processes kill creativity. Pure chaos creates technical debt.

The sweet spot: Spec-driven for architecture, vibe coding for polish.

What's Next

COBRA is just the beginning. With Kiro's systematic approach, I'm planning:

Expand COBOL dialect support (Micro Focus, GnuCOBOL)
Add automated test generation from COBOL test cases
Build migration progress dashboard with cost tracking
Create marketplace for sharing modernization patterns

Try It Yourself

COBRA is open source: github.com/Shaistaaman/COBRA-COBOL-Banking-Resilience-Agent

The spec-driven approach works for any complex project:

Start with requirements.md (what you're building)
Create design.md (how you'll build it)
Generate tasks.md (step-by-step implementation)
Let Kiro execute systematically

Final Thought

Kiro changed how I approach development by teaching me that structure amplifies creativity.

The spec isn't a constraint—it's a foundation that lets you build confidently, knowing your architecture is sound and your progress is trackable.

That's my favorite thing about Kiro: it makes complex projects manageable through systematic thinking, domain expertise, and intelligent automation.

And honestly? It's kind of addictive. #hookedonkiro

Built with: Kiro, TypeScript, React, AWS CDK, Model Context Protocol
Time: 2 weeks from concept to production-ready
Cost: $0 AWS charges during development
Lines of Code: 38,000+ (mostly generated by Kiro)

kiro #aws #cobol #modernization #ai #development

Want to see COBRA in action? Check out the live demo or read the comprehensive documentation.

How to Use AWS Bedrock Guardrails to Minimize Input Token Count

Shaista Aman Khan — Sun, 17 Aug 2025 19:13:51 +0000

When working with large language models (LLMs) on AWS Bedrock, every token matters. The more tokens you use, the higher the cost and the slower the response time. Many developers look for ways to reduce input tokens without losing the quality of responses. One way to achieve this is by using AWS Bedrock Guardrails.

Guardrails are usually thought of as safety features to filter harmful or unwanted content, but they can also help manage input token usage. Let’s look at how.

1. Filter Out Irrelevant Inputs

Sometimes users enter long and irrelevant text. For example, a support chatbot may receive copy-pasted paragraphs that have little to do with the actual problem. Guardrails can be set up to block or reject inputs that fall outside the allowed topics. This prevents sending unnecessary text to the model and saves tokens.

2. Set Maximum Input Lengths

Guardrails allow you to set boundaries on the size of inputs. By defining a maximum input length, you make sure the model does not waste resources processing overly long requests. This helps keep responses fast and costs under control.

3. Use Topic Filtering

If your application is focused on a specific domain, like customer service or healthcare, you can configure Guardrails to only accept relevant inputs. Off-topic requests will be blocked before they reach the model. This reduces the chance of wasting tokens on unrelated content.

4. Combine Guardrails with Pre-Processing

Guardrails work best when combined with a simple pre-processing step. Before sending text to the model:

Clean up redundant or repeated phrases

Summarize long passages into shorter versions

Remove unnecessary details like disclaimers or email signatures

After this, Guardrails can enforce length limits and topic filters to make sure only useful text is sent to the model.

Conclusion

AWS Bedrock Guardrails are more than just safety tools. When used thoughtfully, they can also help reduce token usage by blocking irrelevant, lengthy, or off-topic text. Pairing Guardrails with simple pre-processing steps ensures that your application remains efficient, cost-effective, and focused on what really matters.

CodeFlow: The Debugging Odyssey - Amazon Q and Pygame Adventure

Shaista Aman Khan — Wed, 28 May 2025 12:21:15 +0000

Introduction

Have you ever wanted to visualize what debugging code feels like? CodeFlow: The Debugging Odyssey transforms the abstract concept of debugging into an engaging 2D game experience. As a "Code Cleaner," you'll navigate through digital landscapes, scan for bugs, and fix them using your debugging powers.

This blog post will guide you through setting up and playing CodeFlow on your local machine. Whether you're a programming enthusiast, a game developer, or just someone looking for a fun way to understand debugging concepts, this game offers an entertaining experience with educational undertones.

What is CodeFlow?

CodeFlow is a 2D game built with Python and Pygame that gamifies the debugging process. The core gameplay revolves around:

Moving freely through a digital environment
Scanning for bugs in your code
Using your debugging powers (powered by Q-Energy) to fix these bugs
Collecting Data Bytes to replenish your energy
Completing levels by fixing all bugs before your health depletes

The game features a cyberpunk-inspired aesthetic with neon colors, particle effects, and a digital atmosphere that makes debugging feel like an adventure rather than a chore.

Getting Started

Prerequisites

Before you begin, make sure you have the following installed:

Python 3.x: The programming language used to build the game
Git: For cloning the repository

Step 1: Clone the Repository

Open your terminal and run the following command to clone the CodeFlow repository:

git clone https://github.com/Shaistaaman/CodeFlow/
cd CodeFlow

Step 2: Set Up the Environment

You have two options for setting up the game environment:

Option 1: Using the Installation Script (Recommended)

This is the easiest way to get started, especially if you're new to Python:

# Make the installation script executable
chmod +x install_and_run.sh

# Run the installation script
./install_and_run.sh

This script will:

Create a virtual environment
Install Pygame and other dependencies
Run the game

Option 2: Manual Setup

If you prefer to set things up manually:

# Create a virtual environment
python3 -m venv venv

# Activate the virtual environment
# On macOS/Linux:
source venv/bin/activate
# On Windows:
# venv\Scripts\activate

# Install dependencies
pip install -r requirements.txt

# Run the game
python3 main.py

Step 3: Troubleshooting

If you encounter any issues with the full game, you can try running the simplified version:

python3 simple_game.py

This version has fewer features but is useful for testing if Pygame is working correctly on your system.

How to Play

Controls

Movement: Use arrow keys or WASD to move your character in all directions
Q-Scan: Press Q to scan for bugs in your vicinity (highlighted in purple)
Q-Fix: Press E to fix highlighted bugs (costs Q-Energy)
Collect Data Bytes: Move near blue orbs to collect them and replenish your Q-Energy

Gameplay Tips

Manage Your Resources: Q-Energy is limited, so collect Data Bytes regularly and use your Q-Fix ability strategically.
Scan Before Fixing: Always use Q-Scan (Q key) before attempting to fix bugs. This highlights them and makes them safe to approach.
Watch Your Health: Unhighlighted bugs will damage your health if you touch them. Keep an eye on your health bar in the top-left corner.
Use the Scan Range Indicator: A faint blue circle shows your scan range. Position yourself to maximize the number of bugs you can scan at once.
Move Strategically: You can move in all directions, so use this freedom to navigate efficiently around the level.

Game Screens

1. Splash Screen

The game starts with a splash screen showing the title "CodeFlow: The Debugging Odyssey." Press any key to continue.

2. Main Menu

From here, you can:

Start a new debugging session
Exit the game

Use the up/down arrow keys to navigate and Enter to select.

3. Loading Screen

A brief loading screen with a progress bar appears before each level.

4. Gameplay Screen

This is where the main action happens. You'll see:

Your character (the Code Cleaner)
Bugs that need fixing
Data Bytes to collect
HUD showing your health, Q-Energy, and remaining bugs

5. Level Complete Screen

When you fix all bugs, you'll see your stats:

Time taken
Bugs fixed
Final score

6. Game Over Screen

If your health reaches zero, you'll see the "PROGRAM CRASHED!" screen. Press any key to return to the menu.

Understanding the Code Structure

If you're interested in how the game works or want to modify it, here's a brief overview of the code structure:

main.py: The entry point that initializes the game
settings.py: Contains game constants and configuration
game_states.py: Manages different game screens and states
game_objects.py: Defines game objects like Player, Bug, DataByte, and Particle
assets/: Directory for game assets (currently empty, ready for future expansion)

For a more detailed look at the architecture, check out the architecture.md file in the repository.

Extending the Game

Want to add your own features? Here are some ideas:

New Bug Types: Create different kinds of bugs with unique behaviors
Power-Ups: Add special abilities or temporary boosts
Multiple Levels: Design different levels with increasing difficulty
Sound Effects: Add audio feedback for actions
Visual Improvements: Enhance the graphics with sprites and animations

Educational Value

Beyond being fun, CodeFlow helps visualize important programming concepts:

Debugging: The core gameplay mechanic of finding and fixing bugs
Resource Management: Balancing energy usage with collection
Problem Solving: Strategic planning to fix bugs efficiently
Code Health: The consequences of letting bugs accumulate

Conclusion

CodeFlow: The Debugging Odyssey transforms the often frustrating experience of debugging into an engaging game. By visualizing bugs as entities that can be scanned and fixed, it provides a fresh perspective on programming concepts while delivering an entertaining gameplay experience.

Whether you're using it as a fun break from actual coding or as an educational tool to introduce programming concepts, CodeFlow offers a unique blend of entertainment and learning.

Clone the repository, set up your environment, and start your debugging adventure today!

Architecting for Efficiency: Building Robust DynamoDB Models for Real-World Use Cases

Shaista Aman Khan — Mon, 29 Jan 2024 16:43:41 +0000

Solutions Architect 🧑‍💻👷 are tech doctor? 🩺

I usually listen to tech podcasts and events. I talk to numerous customers and give them the best possible solution which is efficient and within their budget. Just like a doctor listens to your symptoms, takes tests, and diagnoses the illness, a Solutions Architect dives deep into your business needs. I gather requirements, analyze pain points, and understand the goals.

While working on a project I got the chance to introduce myself to AWS Serverless services mainly Lambda, API Gateway, Step Function, Dynamodb, and more. Cloud's true power lies in customization and to get more value you have to architect for efficiency and cost-effectiveness.

In this blog, I will be referring to

Ref Video

This video is about advanced data modeling with DynamoDB. The speaker, Alex Debries, is an AWS data hero and an expert in DynamoDB. He has written a book on DynamoDB and has spoken at several conferences about it. At Reinvent 2023, he effectively presented advanced data modeling tips for a real-world use case.

DynamoDB Basics:

Key terms: tables, items, primary keys, and attributes
Example of an airline application using DynamoDB
Different types of primary keys: simple and composite Item collections.

Designing for DynamoDB:

Understanding how DynamoDB stores data under the hood
Knowing your access patterns: read and write patterns
Thinking about constraints and data distribution
Choosing the right item size

Advanced Data Modeling Patterns:

Booking a flight with DynamoDB: right patterns and constraints
Handling complex filtering with external systems
Integrating DynamoDB with other tools: Elasticsearch, S3

Let's dive into some Dynamodb basics:

DynamoDB is a NoSQL database offered by Amazon Web Services. A NoSQL database is a database that doesn't have a fixed schema, unlike relational databases. This means that you don't have to specify the data types for each attribute upfront.

A DynamoDB table is a collection of items. Each item is a collection of attributes. An attribute is a name-value pair. The primary key is a unique identifier for an item.

There are two types of primary keys: simple and composite.

A simple primary key has a single element, a partition key. A partition key is used to determine how data is partitioned across DynamoDB's servers.

A composite primary key has two elements, a partition key and a sort key. A sort key is used to further partition data within a partition.

Let's use an example of an airline application. In this example, the partition key would be the customer ID and the sort key would be the flight ID.

Let's see item collections. Item collections are a set of records that have the same partition key in a table with a composite primary key.

Here are the steps on how to achieve item collections in the AWS console:

Create a table with a composite primary key. Like Customer_ID as the partition key and Flight_ID as the sort key.
Use the partition key to query for items. You can run a query in AWS Console to see the results.
The results will include all items that have the same partition key, regardless of the sort key value.

Let's deep dive into the details:

1. Understanding Data Storage Under the Hood:

Partitions: DynamoDB partitions data based on the partition key (part of the primary key). Items with the same partition key are stored together in a partition.

**Distribution: **Partitions are distributed across multiple servers for scalability and availability.

Read/Write Capacity Units (RCUs/WCUs): You provision RCUs and WCUs to handle expected read/write traffic.

Example:

Table: CustomerOrders
Primary Key: CustomerID (partition key)
Data Distribution: Orders for each customer are stored together in a partition.
RCUs/WCUs: Allocate based on expected order volume.

2. Knowing Your Access Patterns:

Identify common queries and updates: This dictates table structure and indexing.
Consider read/write frequency and volume: Allocate RCUs/WCUs accordingly.

Example:

Frequent query: Retrieve all orders for a specific customer.
Table structure: Ensure CustomerID is the partition key.
Indexing: Create a Global Secondary Index (GSI) if you need to query by other attributes.

3. Thinking About Constraints:

Item size limit: 400 KB per item.
Attribute size limit: 400 KB per attribute.
10 GB per partition: Distribute data evenly to avoid "hot" partitions.

For more indepth understandin on this, see DynamoDB Core Concept Interview Challenge by Kobe

Example:

Large orders: Store order details in a separate table or S3, referencing them in the main table.

4. Choosing the Right Item Size:

Balance granularity and performance: Smaller items generally mean faster reads/writes.
Denormalize data if needed: Combine related data for frequent access.

Example:

Customer information: Store address, contact details, etc., within the customer item for frequent retrieval.

Additional Considerations:

GSIs: Create secondary indexes for flexible querying, but be mindful of additional costs and write overhead.
Data modeling best practices:
Use composite primary keys (partition key + sort key) for efficient retrieval and sorting.
Consider single-table design for related data.
Use GSIs judiciously.
Monitoring and optimization: Track performance and adjust as needed.

Remember:

DynamoDB is a powerful, scalable NoSQL database, but careful design is crucial for optimal performance and cost-efficiency.
Understanding these key concepts will guide you in creating effective DynamoDB data models.

Moving on to the next level and applying what has been discussed so far:

Advanced Data Modeling Patterns in DynamoDB:

Here's a step-by-step breakdown of the data access patterns, using the example of booking a flight:

1. Booking a Flight with DynamoDB:

a. Right Patterns and Constraints:

Tables:

Flights: Stores flight details (flight ID, origin, destination, date, etc.).
Bookings: Records passenger bookings with references to flights and users.
Users: Stores user information.

Primary Keys:

Flights: FlightID (simple primary key).
Bookings: BookingID (simple primary key).
Users: UserID (simple primary key).

Secondary Indexes:

Global Secondary Index (GSI) on Bookings for FlightID to efficiently query bookings for a specific flight.

Constraints:

Limit Flight size to avoid exceeding the item size limit.
Use timestamps for booking creation and modification for filtering.

b. Booking Process:

User searches for flights using flight details.
Query the Flights table by desired criteria.
User selects a flight and books it.
Create a new item in Bookings with references to user and flight.
Update user availability in the Users table.

2. Handling Complex Filtering with External Systems:

Scenario: Users search for flights with complex criteria (price range, multiple connections, etc.).

Solution:

Store basic flight data in DynamoDB for fast querying.
Offload complex filtering and aggregation to an external system like Elasticsearch.
Use DynamoDB as the source of truth for booking data.
Integrate your application with Elasticsearch to retrieve filtered results and book flights in DynamoDB.

3. Integrating DynamoDB with Other Tools:

a. Elasticsearch:

Use it for complex search and aggregation of flight data with advanced features like faceting and geospatial searches.
Keep basic flight data in DynamoDB for fast lookups and booking.
Synchronize data between DynamoDB and Elasticsearch for consistency.

b. S3:

Store large files like images, PDFs, or flight logs related to bookings.
Use DynamoDB to store references to files in S3.
Leverage S3's scalability and cost-effective storage for large data.

Remember:

Choose the right patterns based on your data access patterns and complexity.
Leverage external systems when DynamoDB alone cannot handle specific tasks.
Maintain data consistency and synchronization between different tools. These patterns could be refined based on your specific requirements and application needs.

It is recommended to watch two other DynamoDB talks at Reinvent 2023: DAT329 and DAT330 for in-depth knowledge of the underlying architecture of Dynamodb.

Understanding GitHub Actions

Shaista Aman Khan — Mon, 27 Nov 2023 11:28:37 +0000

GitHub Actions is a powerful tool provided by GitHub that allows developers to automate workflows for their repositories. It enables automation of tasks such as testing, building, and deploying applications directly from the GitHub repository. In this comprehensive guide, we will explore the various components of GitHub Action.
Some useful links to study in depth about github actions:
Github Quick Start
Github Actions Marketplace
Guides for GitHub Actions

Components of GitHub Actions
1. Workflow
A workflow in GitHub Actions is a configurable automated process that comprises one or more jobs. It is defined using a YAML file named workflow.yml placed in the .github/workflows directory of your repository. Workflows can be triggered based on events like pushes, pull requests, or schedules.

2. Jobs
Jobs are a collection of steps that execute on the same runner. Workflows can contain multiple jobs that run in parallel or sequentially. Each job can define the environment, execution platform, and steps needed to complete the job's tasks.

3. Steps
Steps are individual tasks within a job. They represent the actions performed during the job execution. Each step can be a shell command, an action, or a reference to an external action defined by the community or the repository owner.

4. Actions
Actions are shareable and reusable units of code that can perform specific tasks. They encapsulate individual tasks, making it easier to reuse code across workflows. Actions can be created by the community or by the repository owner and can be used in workflows to perform tasks like building, testing, or deploying applications.

5. Runners
Runners execute jobs in a GitHub Actions workflow. GitHub provides hosted runners with various operating systems (Linux, macOS, Windows) and environments pre-installed. Alternatively, self-hosted runners can be used to customize the execution environment.

Here is how a GitHub action .yml file looks like:

name: Deploy Reactjs App

on:
  push:
    branches:
      - main

jobs:
  deploy:
    runs-on: ubuntu-latest

    steps:
      - name: Checkout Repository
        uses: actions/checkout@v2

      # Add steps to build and deploy the Reactjs application

Now that we understand the fundamental components of GitHub Actions, in the next blog let's proceed with a step-by-step tutorial to deploy a Reactjs application in AWS S3 using GitHub Actions.

Navigating the Storage Spectrum: Data, Files, Blocks, and Objects

Shaista Aman Khan — Wed, 08 Nov 2023 11:30:48 +0000

In our ever-connected, data-driven world, storage lies at the heart of our digital existence. The way we store, manage, and access our data can make a world of difference, both for individuals and organizations. There's no one-size-fits-all solution, as the landscape of storage is as diverse as the data itself. From structured to unstructured, from files and blocks to objects and more, each storage type plays a unique role in the realm of information management.

In this blog, we will explore the storage universe, its various types, and their vital roles in our data-driven lives.

1. File Storage:

Description: File storage is a traditional method of storing data, where files are organized into directories and folders. It allows multiple users or applications to access and share files simultaneously.
AWS: Amazon Elastic File System (EFS) is an AWS service that provides scalable and fully managed file storage, making it easy to set up and share files across multiple EC2 instances. It's well-suited for use cases like content management systems and shared application data.
Alibaba Cloud: Alibaba Cloud Network Attached Storage (NAS) offers fully managed file storage that can be accessed by multiple ECS instances, providing a shared file system for applications.
Google Cloud: Google Cloud Filestore is a managed file storage service designed for enterprise workloads. It allows you to create NFS file shares that can be mounted by multiple virtual machines.
Microsoft Azure: Microsoft Azure File Storage provides fully managed file shares that can be accessed by multiple virtual machines. It is a scalable and reliable solution for file storage in the cloud.

2. Block Storage:

Description: Block storage involves dividing data into fixed-sized blocks and is typically used for more structured, low-level data storage. It is suitable for applications requiring high-speed data transfer and low-latency access.
AWS: Amazon Elastic Block Store (EBS) is a block storage service that allows you to attach persistent block storage volumes to EC2 instances. It's commonly used for hosting databases, running applications, and storing critical data that requires high performance and reliability.
Alibaba Cloud: Alibaba Cloud Elastic Block Storage (EBS) offers high-performance block storage that can be attached to Elastic Compute Service (ECS) instances, suitable for applications that require low-latency and high-speed storage.
Google Cloud: Google Cloud Persistent Disks provide block storage for virtual machine instances. They can be used with Compute Engine instances and offer features like snapshots and auto-resizing.
Microsoft Azure: Microsoft Azure Disk Storage provides block storage that can be attached to Azure virtual machines. Azure Managed Disks simplify disk management, offering high availability and scalability.

3. Object Storage:

Description: Object storage is a data storage architecture that manages data as objects, each with its own unique identifier, metadata, and data. It is well-suited for unstructured data and large-scale storage needs.
AWS: Amazon Simple Storage Service (S3) is a prime example of object storage. AWS S3 allows you to store and retrieve data as objects in buckets. It's suitable for various use cases, including data backups, web hosting, multimedia storage, and data archiving.
Alibaba Cloud: Alibaba Cloud Object Storage Service (OSS) is a highly scalable object storage solution designed for the storage and retrieval of unstructured data, such as images, videos, and backups.
Google Cloud: Google Cloud Storage is a versatile object storage service for storing and retrieving objects of any size. It's commonly used for hosting media files, data backups, and serving static website content.
Microsoft Azure: Microsoft Azure Blob Storage is an object storage service that can store and manage unstructured data. It is suitable for a wide range of use cases, including data archiving, content delivery, and IoT data storage.

4. Data Storage:

Description: Data storage refers to the broader category of storing and managing structured or unstructured data. It encompasses various storage types and is essential for data management and analysis.

Structured Data:
AWS: Amazon Relational Database Service (RDS) is an AWS service that provides managed relational databases, suitable for structured data storage and management.
Alibaba Cloud: ApsaraDB for RDS (Relational Database Service) offers a highly reliable and scalable SQL database service. It's the go-to choice for hosting structured data, such as transaction records, customer information, and financial data, and supports popular relational database engines like MySQL, PostgreSQL, and SQL Server.
Google Cloud: Cloud SQL is a fully managed SQL database service that facilitates the storage and retrieval of structured data. It's suitable for managing structured data like customer records, inventory data, and business applications using popular SQL database engines.
Microsoft Azure: SQL Database is a fully managed SQL database service designed for structured data storage and processing. It provides a robust platform for hosting relational data, making it a great choice for applications that rely on SQL databases for structured data management.

Unstructured Data:
AWS: Amazon DynamoDB is an AWS service that offers a highly scalable, NoSQL database for unstructured or semi-structured data storage. It is ideal for applications that require flexible and fast storage and retrieval of unstructured data, such as JSON documents and key-value pairs.
Alibaba Cloud: Table Store is a NoSQL database service suitable for managing unstructured or semi-structured data. It's an excellent choice for applications dealing with non-relational data types, such as JSON documents and key-value pairs.
Google Cloud: Firestore is a NoSQL database designed for managing semi-structured and unstructured data. It's well-suited for handling documents, JSON data, and other non-relational data types.
Azure: Cosmos DB is Microsoft's globally distributed, multi-model database service that supports NoSQL data storage. It offers a flexible and scalable solution for managing unstructured and semi-structured data, making it ideal for a wide range of applications.

Data-Driven Decision Making

Shaista Aman Khan — Tue, 07 Nov 2023 13:50:00 +0000

Data-driven decisions are important because they help businesses make informed choices that are based on evidence and analysis. This can lead to better outcomes, such as increased profits, improved customer satisfaction, and reduced risk.

There are many reasons why data-driven decision-making is good for businesses.

It can help businesses to identify and solve problems. By analyzing data, businesses can identify areas where they are not performing well and take steps to improve.
It can help businesses to make better decisions about resource allocation. By understanding how their resources are being used, businesses can make more informed decisions about where to allocate them.
It can help businesses to improve customer satisfaction. By understanding their customers' needs and wants, businesses can provide them with better products and services.
It can help businesses to reduce risk. By understanding the risks they face, businesses can take steps to mitigate those risks.

Data-driven decision-making is a powerful tool that can help businesses of all sizes to achieve their goals. Here are 6 steps of data-driven decision-making:

1. Ask questions and define the problem:
Before you start analysing data, it's important to clearly define the problem you're trying to solve or the question you're trying to answer. This will help you focus your data collection and analysis efforts.
Example: If you're a marketing manager for a clothing company, you might want to know which marketing campaigns are most effective in reaching your target audience.

2. Prepare data by collecting and storing the information:
Once you know what you're trying to achieve, you need to collect the relevant data. This data can come from a variety of sources, such as sales records, website analytics, or social media data.
Example: To find out which marketing campaigns are most effective, you might collect data on website traffic, email open rates, and social media engagement.

3. Process data by cleaning and checking the information:
Before you can analyse data, you need to make sure it's accurate and complete. This may involve identifying and correcting errors, handling missing values, and transforming data into a format that's suitable for analysis.
Example: You might find that some of your website traffic data is missing or inaccurate. You'll need to clean up this data before you can use it to draw any conclusions.

4. Analyse data to find patterns, relationships, and trends:
Once your data is clean and ready to go, you can start to analyse it to find patterns, relationships, and trends. This can be done using a variety of statistical and data mining techniques.
Example: You might use statistical analysis to determine which marketing campaigns have a statistically significant impact on website traffic, email open rates, and social media engagement.

5. Share data with your audience:
Once you've analysed your data, you need to communicate your findings to others. This could involve creating reports, presentations, or dashboards.
Example: You might create a report that summarises the results of your analysis and includes charts, graphs, and tables that illustrate your findings.

6. Act on the data and use the analysis results:
The final step in the data-driven decision-making process is to act on the data and use the analysis results to make informed decisions. This could involve implementing new marketing campaigns, adjusting your budget, or changing your product strategy.
Example: Based on the results of your analysis, you might decide to allocate more marketing budget to campaigns that have been shown to be effective in reaching your target audience.

Remember, data-driven decision-making is an iterative process. You may need to go back and forth between steps as you learn more about your data and the problem you're trying to solve.

The Battle of the AWS Managed Services: Amplify <-> Application Composer <-> Cloud Formation

Shaista Aman Khan — Mon, 30 Oct 2023 11:14:07 +0000

AWS Amplify, AWS Application Composer, and AWS CloudFormation are three different AWS services that help developers build and manage cloud applications. Each service has its own unique strengths and use cases, so it is important to choose the right one for your specific needs.

AWS Amplify is a full-stack development framework that helps developers build, ship, and host web and mobile applications on AWS. Amplify provides a wide range of features and services, including:

Backend services:
Amplify provides pre-built backend services, such as authentication, storage, and API management, which can be easily integrated into your application.
Frontend libraries:
Amplify provides a library of pre-built frontend components for popular web and mobile frameworks, such as React, Angular, and NativeScript.
Deployment and hosting:
Amplify makes it easy to deploy and host your application on AWS, with CI/CD integration and built-in security features.

AWS Application Composer is a visual builder for modern applications on AWS. Application Composer makes it easy to design and deploy your application architecture without having to write any code. With Application Composer, you can drag and drop AWS services onto a canvas to create a visual representation of your application. Application Composer will then generate the necessary infrastructure as code (IaC) templates for you.

AWS CloudFormation is a template-based service for provisioning and managing AWS resources. CloudFormation templates are written in JSON or YAML, and they define the resources that you want to create and how you want them to be configured. CloudFormation can be used to provision any AWS resource, including EC2 instances, S3 buckets, and Lambda functions.

Here is a table that summarizes the key differences between AWS Amplify, AWS Application Composer, and AWS CloudFormation:

If you are a full-stack developer and you want to have more control over your application architecture, then AWS Application Composer is a good option. Application Composer makes it easy to design and deploy your application architecture without having to write any code.

If you are an experienced developer and you need more flexibility in how you provision and manage your AWS resources, then AWS CloudFormation is a good option. CloudFormation allows you to define your infrastructure as code, which gives you more control over your environment.

Example use cases

Here are some example use cases for each service:

AWS Amplify

Building a web application using React and hosting it on AWS
Developing a mobile app using NativeScript and using AWS Amplify for authentication and storage
Creating a serverless backend for your web or mobile application

AWS Application Composer

Designing and deploying a serverless application architecture using AWS Lambda, Amazon EventBridge, and Amazon S3
Creating a multi-tier architecture with EC2 instances, RDS databases, and S3 buckets
Deploying a complex application architecture with multiple microservices and interconnected resources

AWS CloudFormation

Provisioning and managing the infrastructure for a new AWS account
Creating a template for a development environment that you can deploy to multiple AWS accounts
Creating a template for a production environment that meets your specific compliance requirements

Conclusion

AWS Amplify and AWS Application Composer are powerful tools that can help you build and manage cloud applications. The best service for you will depend on your specific needs and requirements. Both of them are evolving services and new features and capabilities are being added all the time. It is important to stay up-to-date on the latest developments so that you can choose the best service for your needs.

AWS Route 53 Routing Policies & Record Sets: A Comprehensive Guide to Efficient Domain Management

Shaista Aman Khan — Tue, 17 Oct 2023 04:18:15 +0000

In previous blogs, we bought a domain and created a hosted zone. To add a record set first you need to understand routing policies and types of record sets to efficiently manage your domain. Now, let's explore the various routing policies and record set types offered by Route 53:

Routing Policies:
1. Simple Routing Policy
The Simple Routing Policy allows you to map a single DNS record to multiple IP addresses. When a query is made, Route 53 returns all associated IP addresses in a round-robin fashion.

2. Weighted Routing Policy
The Weighted Routing Policy enables you to split traffic based on different weights assigned to each resource record set. This means you can direct more traffic to certain endpoints and less to others, making it ideal for load balancing.

3. Latency Routing Policy
The Latency Routing Policy directs traffic based on the lowest network latency between the user and the endpoint. Users are routed to the server with the least latency, ensuring the best performance.

4. Failover Routing Policy
The Failover Routing Policy is used for high-availability setups. You can configure a primary resource and a secondary (backup) resource. Route 53 monitors the health of the primary resource and automatically switches to the backup resource if the primary one becomes unavailable.

5. Geolocation Routing Policy
The Geolocation Routing Policy allows you to route traffic based on the geographic location of the user. You can define policies that specify which resource to use for users from specific regions or countries.

6. Geoproximity Routing Policy
The Geoproximity Routing Policy takes geographical proximity into account. It routes traffic based on the physical location of your resources and the location of your users, enabling you to optimize traffic routing.

7. Multi-Value Routing Policy
The Multi-Value Routing Policy is similar to the Simple Routing Policy but allows you to associate multiple values (IP addresses or resources) with a single DNS name. This provides fault tolerance and load balancing.

AWS Route 53 is a fundamental component of building reliable and scalable web applications. The ability to choose from various routing policies empowers you to fine-tune traffic routing to meet your specific needs. By understanding the definitions and use cases of these routing policies, you can ensure that your applications run smoothly, deliver high performance, and remain highly available. So, whether you're directing traffic for a simple website or a complex application, Route 53's routing policies offer you the flexibility and control you need for efficient domain management. For more details Route 53 Routing ploicies

Now let's jump into record set type.

Record Set:
A record set is a collection of DNS records that share the same name and type. These records specify how Route 53 responds to DNS queries for a specific domain name.

1. A Record Set (IPv4 Address)
An "A" record set maps a domain name to one or more IPv4 addresses. It's the most common record set type used for pointing domain names to web servers, email servers, or any service with an IPv4 address.

2. AAAA Record Set (IPv6 Address)
Similar to the "A" record, the "AAAA" record set maps a domain name to one or more IPv6 addresses. This is crucial for ensuring connectivity over IPv6, as the availability of IPv6 addresses increases.

3. CNAME Record Set (Canonical Name)
A "CNAME" record set is used to create an alias for another domain name. It allows one domain to redirect to another domain's name, making it an essential tool for creating subdomains or managing domain aliases.

4. MX Record Set (Mail Exchange)
The "MX" record set defines the mail servers responsible for receiving email for a specific domain. It's used to route email to the correct mail servers and is crucial for configuring email services.

5. TXT Record Set (Text)
A "TXT" record set is used to store text information, such as SPF (Sender Policy Framework) records for email authentication, or other arbitrary text data.

6. SRV Record Set (Service Locator)
The "SRV" record set is used to specify the location of services for applications, like VoIP and instant messaging. It includes information about the server's hostname and port number.

7. NS Record Set (Name Server)
The "NS" record set specifies the authoritative name servers for a domain. It's essential for configuring and managing DNS delegation.

8. PTR Record Set (Pointer)
A "PTR" record set is used for reverse DNS lookup, mapping IP addresses to domain names. These are typically managed by the entity responsible for the IP address space.

9. SOA Record Set (Start of Authority)
The "SOA" record set contains administrative information about the zone. It includes details like the primary name server, the responsible person's email address, and other important zone information.

Understanding the various Route 53 record set types is crucial for managing DNS configurations effectively. Each record set type serves a unique purpose, allowing you to control how DNS queries are resolved for your domain names. Whether you're setting up a website, configuring email services, or managing complex applications, Route 53 provides the flexibility and tools to ensure seamless traffic routing and domain management. By harnessing the power of these record-set types, you can maintain a reliable and high-performance online presence. For more details Supported DNS Record Types

Demystifying Hosted Zones: A Step-by-Step Guide to Setting Up Your AWS Route 53 Hosted Zone

Shaista Aman Khan — Tue, 17 Oct 2023 03:48:30 +0000

In the previous blog, we talked about domain purchase steps. Now, it's time to configure a hosted zone for your domain. A hosted zone is a container for DNS records, and it plays a critical role in managing how your domain behaves. In this step-by-step guide, we'll walk you through the process of setting up a hosted zone for your purchased domain in AWS Route 53.

Step 1: Sign in to AWS Console
First, sign in to your AWS account if you haven't already. Once you're logged in, navigate to the AWS Management Console.

Step 2: Access Route 53
From the AWS Management Console, locate the "Services" dropdown in the top left corner and click it. Scroll down to the "Networking & Content Delivery" section, then select "Route 53."

Step 3: Choose "Hosted Zones"
In the Route 53 dashboard, on the left-hand side, you'll find a list of services. Click on "Hosted Zones." This is where you can create and manage hosted zones for your domains.

Step 4: Create a Hosted Zone
Now, let's create a new hosted zone. Click the "Create Hosted Zone" button.

Step 5: Configure the Hosted Zone Settings
In the "Create Hosted Zone" wizard, you'll be prompted to enter the following information:

Domain Name: Enter the domain name you've purchased, like "exampletoday.com."

Type: You can choose either "Public Hosted Zone" or "Private Hosted Zone." For most cases, select "Public Hosted Zone" for domains meant to be accessible on the internet.

AWS Route 53

Once you've filled in these details, click the "Create" button.

Step 6: Get Name Servers
After creating the hosted zone, you'll be directed to the hosted zone details page. Here, you'll find a list of records and the name servers associated with your hosted zone. Make note of these name servers, as you'll need to update your domain's DNS settings to point to them.

Step 7: Update DNS at Your Domain Registrar
Go to Registered Domains and click exampletoday.com or Log in to your domain registrar's account where you purchased the domain. Look for the option to manage your domain or update DNS settings.

Change Name Servers: Update the name servers for your domain with the values provided in your AWS Route 53 hosted zone. These changes might take some time to propagate through the internet, so be patient.

Step 8: Add DNS Records
If you want to set up specific DNS records for your domain, you can do so in the hosted zone. Common DNS records include A (Address) records for pointing to an IP address, CNAME (Canonical Name) records for aliases, and MX (Mail Exchange) records for email routing.

Supported DNS record types

To add a DNS record:

In the hosted zone details, click the "Create Record Set" button.
Choose the type of record you want to add and provide the necessary information.

Step 9: Verify DNS Propagation
It may take some time (up to 48 hours) for DNS changes to propagate globally. You can use online tools to check the status of your DNS records and ensure they are correctly configured.

You've successfully set up a hosted zone for your purchased domain on AWS Route 53. Your domain is now ready to be used, and you have the flexibility to manage its DNS records and settings as needed.

Mastering the Art of Domain Ownership: Step-by-Step Guide to Buying Domains on AWS Route 53

Shaista Aman Khan — Mon, 16 Oct 2023 11:13:10 +0000

In today's digital age, owning a domain is the first step towards establishing your online presence. Amazon Web Services (AWS) offers an excellent service called Route 53 for domain registration and management. Whether you're a business owner, a blogger, or an aspiring web developer, Route 53 makes it easy to secure your own domain. In this step-by-step guide, we'll walk you through the process of buying a domain on AWS Route 53.

Step 1: Sign in to AWS Console
The first thing you need to do is sign in to your AWS account. If you don't have an AWS account, you'll need to create one. Once you're logged in, navigate to the AWS Management Console.

Step 2: Access Route 53
From the AWS Management Console, locate "Services" in the top left corner and click it. Then, scroll down to the "Networking & Content Delivery" section and select "Route 53."

Step 3: Choose "Registered Domains"
In the Route 53 dashboard, you will find a list of services on the left-hand side. Click on "Registered Domains." This is where you can search for and purchase domains.

Step 4: Search for Your Desired Domain
In the "Registered Domains" section, you will find a search bar where you can enter the domain name you want to purchase. Once you've entered the domain name, click the "Check" button to see if it's available. If it's available, you can proceed to add it to your cart.

Step 5: Add Domain to Cart
If your desired domain is available, click on it to select it, and then click the "Add to Cart" button.

Step 6: Review Your Selection
You will now be directed to your shopping cart, where you can review your domain selection. Confirm that it's the correct domain and check for any additional services you may want to add, such as domain privacy protection.

Step 7: Choose the Registration Duration
You'll also need to choose the length of time for which you want to register your domain. You can select options like 1 year, 2 years, or more, depending on your preference.

Step 8: Review and Confirm
After configuring your DNS settings and choosing the registration duration, review your order to ensure everything is correct. If you're satisfied, click the "Add to Cart" button to proceed.

Step 9: Checkout
Now, you'll need to complete the checkout process by providing your payment information and billing details. Once you've entered this information, review it carefully and click the "Purchase" button to buy the domain.

Step 10: Domain Ownership Verification
After successfully purchasing the domain, Route 53 may require you to verify your ownership of the domain. This usually involves confirming your contact information through an email.

Step 11: Domain Registration Complete
Once the ownership verification is complete, you will officially own the domain. Congratulations! You've successfully purchased a domain on AWS Route 53.

In conclusion, buying a domain on AWS Route 53 is a straightforward process. With this step-by-step guide, you can secure your own domain quickly and easily. Remember that managing your domain, including configuring DNS records and renewing your registration, is equally important to maintain your online presence.

Intercity Ride-Sharing App - Amplify Hackathon 2023

Shaista Aman Khan — Tue, 01 Aug 2023 03:37:36 +0000

https://www.sharewaow.com/ - Community Sharing Made Easy

Sharewaow is a community ride-sharing app that connects people traveling from one city to another. Riders can share rides with others going to the same destination, either for a fee or for free. Sharewaow is a great platform to save money on transportation, reduce your carbon footprint, and meet new people.

How Sharewaow Works To use Sharewaow, simply create an account and enter your travel details. You can then search for rides that are going to your destination. If you find a ride that you're interested in, you can book it and pay the driver directly. You can also offer to share your ride with other people, either for a fee or for free.

Benefits of Sharewaow There are many benefits to using Sharewaow, including:

Save money on transportation: Sharewaow is a great way to save money on transportation. You can split the cost of gas with other riders, or you can even offer to carpool for free.

Reduce your carbon footprint: Sharewaow is a great way to reduce your carbon footprint. By sharing rides, you can reduce the number of cars on the road, which will help to lower emissions.

Meet new people: Sharewaow is a great way to meet new people. You can meet people who are interested in the same things as you, and you can make new friends along the way.

SDG Goals Addressed Sharewaow addresses the following SDG goals:

SDG 13: Climate action: Sharewaow helps to reduce carbon emissions by reducing the number of cars on the road.

SDG 11: Sustainable cities and communities: Sharewaow helps to create more sustainable cities and communities by reducing traffic congestion and pollution.

SDG 17: Partnerships for the goals: Sharewaow is a partnership between individuals and communities to create a more sustainable future.

Inspiration I use to travel a lot and especially on holidays when everyone is traveling to their hometowns for vacation (celebrations like Eid, Christmas etc). In those days subway transportation and railways are fully packed. One can hardly find a space even on advance payments.

On the other hand, some people take their vehicles with them. It's beneficial for them to earn extra bucks while traveling to their homes. There are many inspirations for making an intercity ride-sharing app. Here are a few:

The rise of ride-sharing apps The success of ride-sharing apps like Uber and Lyft has shown that there is a demand for on-demand transportation. An intercity ride-sharing app could tap into this demand by providing a way for people to share rides between cities.

The need for more sustainable transportation options Intercity travel is a major source of greenhouse gas emissions. An intercity ride-sharing app could help to reduce these emissions by encouraging people to carpool or share rides with other travelers.

The desire to connect with other people Intercity travel can be a lonely experience. An intercity ride-sharing app could help to connect people with other travelers who are interested in the same things.

Sharewaow is a great way to save money, reduce your carbon footprint, and meet new people. If you're looking for a more sustainable way to travel, Sharewaow is a great option.

Github Link https://github.com/Shaistaaman/sharewaow

Web App Link https://www.sharewaow.com

Prerequisites Fundamental knowledge of React Familiarity with Figma AWS Account and Service Knowledge Passion to develop something!

Data Model Before you jump into the development, draft down all necessary data models and access patterns. It's very important to see all access patterns because when you start working on UI and add or remove some attributes, it messes up with data and its relationships.

UI Design in Amplify Studio
Amplify studio facilitates backend devs to easily develop amazing UI with minimal designing knowledge in Figma. One can easily generate React Components with Amplify Studio in few clicks.

Steps to Develop Sharewaow Here is the summary of steps on how we developed a web app for intercity ride sharing on AWS Amplify using Amplify Studio:

Designed the app in Figma Created app's UI components on Figma by template AWS Amplify UI Kit and then defined the app's data models and interactions.

Import the Figma design into Amplify Studio Amplify Studio will automatically generate React code for the app's UI components which was then customized as needed.

Configure the app's data models and storage Then added Dynamodb tables and Storage from Amplify Studio. Dynamodb Tables are added automatically when we created datamodels. We also configured storage for images.

Configure the app's authentication Then we added a Cognito user pool from Amplify Studio by adding Auth for the app. You can also configure the app to use other authentication providers, such as Google or Facebook but for simplicity, we used default Auth settings.

Deploy the app to AWS We designed UI in Amplify Studio and hosted the frontend by GitHub repo and used Amplify pull/push commands to deploy the backend.

How to Make your own copy of Sharewaow
First of all log in to your AWS account and go to AWS Amplify from menu.

Continue to Start in Amplify Studio.

Give it a name "Sharewaow" and "Confirm Deployment". It will take sometime to setup studio.

Launch Studio.

Select Data and Setup on the left navigation menu.

Define your Rides data model.

Save and Deploy

Now switch to Figma and search "Amplify UI Kit" in community search.
OR
Switch to UI Library and Sync with Figma to get the Template to start with

Then "Get a Copy" and start designing your UI Components in "My Components" Page

You can directly configure your UI components or Bind them with data model in UI Library.

Setup a Local AWS Amplify Application

Create a React app using your command line interface and install the AWS Amplify CLI:

npm install -g @aws-amplify/cli

Switch back to Amplify Studio and click Local Setup Guide on top right corner. Here you will receive an amplify pull command for your application - note that the application ID will be specific to your application. Copy this command by clicking on it, then run the command in your CLI and allow CLI to access your amplify project.

Amplify Configure
Install Amplify libraries and React components.
npm i aws-amplify @aws-amplify/ui-react

and start building sharewaow app as mentioned in github repo here

Challenges
Amplify Studio is bit new and it has limited documentation and video tutorials which makes it hard to understand and design UI.

Data Manager is also a challenge but useful feature. But to properly understand your data and its relations try to spend time on data entry.

Amplify Pull command and version upgrade was a tough challenge. Through out the hackathon development my backend folder disappear and took long time to keep things on track.

Team Members Developer - Shaista Aman https://www.linkedin.com/in/shaista-aman/

Cloud Engr -Shadab Aman https://www.linkedin.com/in/shadab-aman/

Nayab Aman - UI/UX https://www.linkedin.com/in/nayab-aman/

Future Work This is not a one-day idea to work on. In developing countries, people often need items on a daily basis. For this hackathon, we just implemented ride sharing but food, clothes, and books sharing is also in the pipeline. Moreover, some other features in consideration are:

Items Request Flow - so that users can request their needed items.

Location - As the web app loads it will ask the user for location so that Sharewaow can recommend items near the user.

Security - Hide sharer phone number and prompt the user to log in before seeing contact details for sharer.

AWSAmplify #AWSAmplifyHackathon #Ridesharing #Carpooling