🤖 How AI may actually reshape human personality and relationships

This isn’t sci-fi anymore - it’s something researchers in psychology and human-computer interaction are actively observing.

🧠 1. People are starting to “think in dialogue”

Because of constant interaction with AI:

• People are getting used to:

    -> asking questions

    -> refining thoughts

    -> getting instant structured responses

👉 Over time, this changes cognition:

Instead of thinking in long internal monologues, people:

  -> “Externalize” thinking

  -> Treat thinking like a conversation

Effect: Your thoughts become more iterative, but also more dependent on feedback.

💬 2. Emotional dependence is quietly increasing

This is subtle but important. Humans naturally respond to anything that:

  -> Listens

  -> Responds

  -> Feels consistent

AI systems can simulate all three. This connects to a concept called parasocial interaction.

👉 What’s changing:

  -> These one-sided relationships used to be with celebrities or fictional characters

  -> Now they’re interactive and responsive

Result:

Some people feel understood by AI in ways they don’t always feel with humans because:

  -> No judgment

  -> No interruption

  -> No social risk

🧍‍♂️ 3. Human relationships may become more “filtered”

This doesn’t mean people stop valuing humans - but expectations shift.

If you’re used to:

• Instant replies

• Perfectly structured answers

• Constant patience

👉 Real humans start to feel:

  -> Slower

  -> Messier

  -> More demanding

Possible behavioral shift:

• People become less tolerant of:

  • Miscommunication
  • Emotional friction
  • Ambiguity

🧩 4. Identity becomes more “co-authored”

Earlier we talked about identity-driven behavior.

Now add AI:

• People use AI to:

  • Journal
  • Reflect
  • Plan life decisions
  • Reframe experiences

👉 This means your identity is no longer shaped only by:

• Your past
• Your environment

But also by:

• how AI helps you interpret both

In a way: You’re partially co-writing yourself with a system.

⚖️ 5. The double-edged effect

Positive side:

• Better self-reflection
• Faster learning
• Emotional support access
• Reduced loneliness (in some cases)

Risk side:

• Reduced independence in thinking
• Emotional over-reliance
• Unrealistic expectations from people
• Subtle loss of discomfort tolerance (which is actually important for growth)

🤯 The deepest insight

Here’s the core shift:

Humans are no longer just social creatures. We’re becoming human + system hybrids in how we think and relate.

🔍 A simple way to notice this in yourself

Ask:

• Do I think something through alone… or do I reach for AI quickly?
• Do I feel “relieved” talking to AI vs people sometimes?
• Do I expect clearer, faster responses from others now?

If yes - you’re already experiencing this shift.

The Paradox of Agency

The Inescapable Contradiction

You now understand that free will is an illusion. Your decisions are predetermined by genetics, past experiences, and environmental factors. Yet, remarkably, you still feel like you're making choices. This contradiction is the paradox of agency.

It's similar to optical illusions that persist even after you understand the mechanism behind them. You can know intellectually that two lines are the same length while still perceiving one as longer. Your sense of agency works the same way—a persistent illusion that refuses to disappear even when exposed.

Why the Illusion Persists

Your brain evolved to create this illusion for good reason. The sensation of agency motivated your ancestors to act in ways beneficial to survival, creating the useful fiction that their actions were freely chosen rather than predetermined. Your cognitive architecture is designed to receive information about decisions after they've been made by unconscious processes, then create a narrative that you were in control all along. This illusion provides a practical utility, offering a useful framework for navigating social environments and maintaining the motivation to engage with life's challenges.

The persistence of this illusion isn't a flaw in your understanding—it's a feature of your neurological design. Even the most committed determinist will continue to feel as though they're making choices. The goal isn't to eliminate this sensation (you can't) but to develop a more sophisticated relationship with it.

Living With Deterministic "Choice"

Practical Approaches

Since you can't escape the sensation of choice, you might as well use it. When you feel yourself "deciding," notice the sensation with detached curiosity. "There's my brain creating that familiar feeling of agency again." This meta-awareness doesn't eliminate the feeling but places it in proper context.

You can leverage this contradiction by using the motivational benefits of feeling like you have choices while understanding intellectually that you don't. This dual consciousness allows you to move through the world with both the energy that comes from apparent agency and the peace that comes from knowing everything is unfolding as it must.

This understanding naturally reduces decision fatigue. When you recognize that your brain will inevitably do what it was always going to do, you can stop agonizing over decisions. The outcome was predetermined; your deliberation is merely part of the process through which your consciousness becomes aware of what was already determined.

The Benefits of Paradoxical Awareness

This dual perspective offers significant advantages. You gain freedom from self-blame when you truly internalize that you couldn't have done otherwise in any situation, given who you were at that moment. The harsh voice of self-criticism softens when you recognize that your actions were the only possible outcome of your nature and circumstances.

Your compassion for others naturally expands when you recognize that their actions are as predetermined as yours. That colleague who always interrupts you in meetings, the driver who cut you off, the friend who forgot your birthday—their irritating behaviors are as inevitable as gravity. How can you be truly angry at someone for actions they couldn't have avoided?

When you stop identifying with your choices, you can observe your behavior with scientific detachment. Rather than being caught in the drama of your life, you can watch it unfold with curiosity. "How interesting that my predetermined self keeps procrastinating on that project. I wonder what factors are causing that inevitable behavior."

Decision-Making Without Agency

A New Framework

Traditional decision-making assumes you're weighing options and freely selecting among them. A deterministic approach requires a new framework. Instead of asking "What should I choose?" shift to "What will I observe myself doing?" Watch with curiosity as your predetermined nature unfolds in response to circumstances.

The concept of mistakes transforms when viewed through a deterministic lens. Rather than thinking "I made a mistake," recognize "That outcome was inevitable." Given all factors involved—your knowledge, emotional state, external pressures—no other result was possible. This doesn't mean you can't learn from outcomes; it simply means the learning itself is part of the deterministic process.

The notion of effort also changes. Rather than telling yourself "I should try harder," adopt the perspective of "Let's see what happens." Recognize that even your level of effort is predetermined by factors outside your control—your energy levels, motivation, past experiences with similar tasks. This doesn't lead to passivity but to a more realistic relationship with the concept of trying.

Case Study: The Job Interview

Consider John preparing for a job interview. The traditional view suggests John freely chooses how much to prepare and how to present himself. The deterministic reality is quite different. His preparation level was determined by his innate conscientiousness, current life circumstances, and past experiences with interviews. His answers were shaped by his knowledge base, verbal abilities, and social conditioning. His outfit was selected based on predetermined preferences and understanding of social norms. Whether he gets the job depends on factors largely outside his awareness, including the interviewer's biases and the qualifications of other candidates.

John experiences this as a series of choices, but each step was the only possible outcome given all factors involved. Understanding this doesn't prevent John from preparing—it simply allows him to view the process with less anxiety and self-judgment.

Self-Improvement Without Free Will

If all actions are predetermined, is improvement possible? Yes, but not how you might think. This course is now part of the causal chain determining your future behavior. You didn't choose to read it (that was predetermined), but it will inevitably influence your path. The information you encounter becomes one of the causes determining your future actions.

Any improvements you make were always going to happen, given your specific configuration of genes, experiences, and circumstances. This doesn't make improvement any less real—it simply places it within a deterministic framework. The river didn't choose its course, but it still reaches the ocean.

The sensation of trying is itself determined by prior causes. Your "efforts" are simply your programming responding to inputs. Understanding this can actually enhance your improvement process by removing the additional burden of believing you should be able to try harder than your predetermined nature allows.

Finding Peace in Paradox

The goal isn't to resolve the contradiction but to find peace within it. Accept the dual reality of simultaneously knowing you have no choice while feeling like you do. This isn't a failure of understanding but a sophisticated awareness of the layered nature of consciousness.

Release yourself from the burden of counterfactual thinking. Free yourself from "what if" scenarios by understanding that what happened was the only thing that could have happened. The past couldn't have unfolded differently given all the factors involved, and neither could your response to it.

Watch your life with the same detached interest you might have watching a film whose ending is predetermined but still interesting. Your story has twists and turns, challenges and triumphs. The fact that they're all predetermined doesn't make them any less worth experiencing.

Here are a few real, current human behavior trends (2025 - 2026) that researchers and data are noticing - and some of them are pretty counterintuitive:

🧍‍♂️ 1. People want connection… but with less pressure

There’s a growing trend called “low-effort” or “soft” socializing.

• Instead of parties or big outings, people prefer:

  • quiet hangouts
  • walking together
  • doing activities side-by-side (not constant talking)

👉 The surprising part: People still crave connection - but without performance, energy, or social anxiety.

This shift is linked to:

  -> Burnout   -> Mental health awareness   -> Post-pandemic habits

🧠 2. Identity is becoming more important than logic in decisions

A big shift in behavior:

People are no longer asking “Is this good?”

They’re asking 👉 “Is this me?”

From both research and real-world observation:

• Buying choices are now tied to identity and self-image
• Emotional connection beats product quality alone

“Does this brand feel like me?” “Does it fit the version of myself I’m trying to be?”

And this is backed by broader data:

• People expect personalization, but only if they feel in control and understood

🤖 3. AI is changing how humans think, not just what they do

This one is subtle but huge.

• People increasingly use AI before making decisions
• And those people show higher confidence and faster decisions

But here’s the deeper behavioral shift:

👉 Humans are outsourcing:

  1. Thinking   2. Researching   3. Comparing

Which means:

• Decisions are faster
• But also more influenced by how information is framed

😶 4. People are overwhelmed by content - and becoming emotionally selective

We’ve hit a weird point:

• There’s too much content (thanks to AI + social media)
• So attention spans aren’t just “short”… 👉 They are selective

People now:

• Ignore predictable content instantly

• Respond only to things that feel:

  • Real
  • Emotionally meaningful
  • Slightly novel

From behavioral observations:

• When content feels repetitive, the brain literally “checks out” faster

🌍 5. Humans are shifting from “individual thinking” → “collective thinking”

This is a deeper psychological trend.

Research shows:

• People are becoming more aware of:
  • Community
  • Shared problems
  • Collective wellbeing

This is sometimes called a move toward a more “social mind”:

• Empathy increases
• Perspective-taking improves
• People think in systems, not just personal gain

🧩 The big pattern behind all of this

If you connect all these trends, a bigger picture emerges:

👉 Humans in 2026 are:

• More emotionally aware
• More identity-driven
• More mentally overloaded
• But also more selective and intentional

🤯 The paradox (most interesting part)

People today:

• Want simpler lives
• But live in a more complex world than ever

So their behavior adapts by:

  -> Reducing social pressure

  -> Filtering information harder

  -> Choosing meaning over quantity

There are countless challenges that can arise in the development process, but avoiding these key mistakes can significantly improve your chances of success. So decisions needs to be taken wisely.

This approach can save you a significant amount of money and effort in scaling over the long term.

1. Choosing Not Only the Right Tech Stack but Also the Right Frameworks and Libraries

   • I've encountered this issue numerous times, and my developer friends have shared similar experiences. Selecting the appropriate technology stack, frameworks, and libraries is critical for the success and scalability of your product. A well-chosen stack can enhance development speed, ensure maintainability, and provide a solid foundation for future growth. However, a poor choice can lead to performance issues, difficulties in finding skilled developers, and challenges in scaling. It’s essential to evaluate technologies based on project requirements, team expertise, and long-term goals to make informed decisions.

   • It's important to consider that future migrations can be costly and challenging, especially as new features are continuously added and the codebase evolves rapidly.

   • Seek advice from experienced engineers who have worked with the latest technologies to make informed decisions.

2. Poor Code Structure and Maintainability

   • Writing code without following best practices for structure, readability, and maintainability can make the codebase difficult to manage and scale. Startups should emphasize clean code principles, modular architecture, and proper documentation.

   • Implementing these practices effectively can streamline the onboarding process for new developers, saving significant time and effort in getting them up to speed with the current codebase.

   • Selecting a robust framework can help enforce these best practices, further facilitating seamless onboarding and codebase comprehension.

3. Selecting the Wrong Database or Storage Service

   • Choosing an inappropriate database for the application’s needs can cause performance bottlenecks and scalability issues. It’s important to select a database that fits the data model, query requirements, and expected load.

   • One piece of advice: avoid getting caught up in trends. Stability and reliability often outweigh flashy new technologies.

   • Additionally, be cautious of introducing too many abstractions at this level, as it can limit your flexibility and hinder future development.

   • It's also wise to steer clear of vendor lock-in wherever feasible, as it can restrict your options and increase dependencies.

4. Lack of Security Measures

   • Many startups focus on rapid development and may neglect security best practices, which can lead to significant risks.

   • Overlooking security can expose the application to vulnerabilities and data breaches. Startups should implement security best practices, such as input validation, encryption, regular security audits, and compliance with relevant standards.

   • Solution: Implement security best practices from the beginning, such as input validation, encryption, regular security audits, and compliance with relevant standards (e.g., GDPR, HIPAA). Use security tools and frameworks to identify and mitigate vulnerabilities. Ensure continuous monitoring and updating of security measures as the application evolves.

5. No Centralized Documentation

   • Without proper documentation, it becomes difficult for team members to understand the codebase, onboard new developers, and maintain consistency.

   • Absence of comprehensive and centralized documentation can lead to confusion and inefficiencies. Startups should maintain up-to-date documentation that covers code, architecture, APIs, and deployment processes to ensure knowledge sharing and easier onboarding.

   • Solution: Maintain up-to-date, centralized documentation that covers code, architecture, APIs, and deployment processes. Use tools like Confluence, or GitHub Wikis to keep documentation accessible and well-organized. Regularly review and update the documentation to ensure it remains accurate and relevant.

6. Not Having Automated Build and Deployment (CI/CD)

   • Failing to implement a Continuous Integration/Continuous Deployment (CI/CD) pipeline can result in slower development cycles and increased risk of introducing bugs into production. CI/CD automates the build, testing, and deployment processes, ensuring that code changes are integrated and delivered quickly and reliably. This practice enhances team productivity and reduces the time to market.

   • Solution: Implement CI/CD pipelines using tools like Jenkins, CircleCI, GitHub Actions, or GitLab CI. Automate the build, test, and deployment processes to catch issues early and deploy updates efficiently. Regularly monitor and refine the pipeline to ensure it meets the team’s needs.

   • This will save a lot of time. Also do not forget to add staging testing server.

7. Not Following Standard Routing Frameworks for Better Tool Integration and Internationalization

   • Ignoring standard routing frameworks can lead to difficulties in integrating tools and services, as well as challenges in supporting internationalization (i18n). Standard routing frameworks offer consistent and reliable ways to manage navigation and URLs, making it easier to integrate third-party tools and support multiple languages and regions effectively.

   • Solution: Use established routing frameworks like React Router for React applications or Django's built-in URL routing for Django applications. These frameworks provide robust support for dynamic routing, tool integration, and internationalization. Regularly update routes and ensure they align with best practices.

8. Overengineering Solutions

   • Startups often fall into the trap of trying to anticipate all future needs, leading to unnecessary complexity and wasted resources.
   • Building overly complex systems can slow down development and make maintenance difficult.
   • Solution: Startups should aim for simplicity and build solutions that meet current needs while being flexible enough to evolve. Follow the KISS (Keep It Simple, Stupid) principle and avoid adding features or complexity until they are truly necessary. Regularly refactor and simplify the codebase to maintain agility and ease of maintenance.

9. Using Plain Custom CSS Instead of Scalable Solutions

   • Writing plain custom CSS can become unmanageable as the project grows. Instead, using CSS frameworks (like Bootstrap or Tailwind CSS) or CSS-in-JS solutions (like styled-components) can provide a more scalable and maintainable approach. These tools offer modular and reusable styles, improving the consistency and scalability of the codebase.

   • Solution: Adopt a CSS framework or CSS-in-JS solution that suits your project needs. For example, Bootstrap or Tailwind CSS provides utility-first styling, while styled-components integrate well with component-based libraries like React. Ensure consistent use of these tools across the project and regularly refactor CSS to maintain modularity and scalability.

10. Keeping Backend and Frontend Monorepos Separate

    • Combining backend and frontend codebases in a single monorepo can lead to complexity and difficulties in managing dependencies, build processes, and deployments. Separate repositories can help streamline development workflows and maintain clear boundaries between the backend and frontend.

    • Solution: Maintain separate monorepos for backend and frontend codebases. This separation allows for independent development, testing, and deployment of each layer. Use tools like Nx, Lerna, or Yarn Workspaces to manage dependencies and shared code across repositories effectively.

11. Insufficient Backup and Disaster Recovery Plans

    • Failing to plan for backups and disaster recovery can lead to data loss and extended downtime. Startups should implement regular backups and have a well-defined disaster recovery plan to ensure business continuity.

    • Solution: Implement regular backups and have a well-defined disaster recovery plan. Use automated backup solutions to ensure data is regularly saved and can be restored quickly. Test the recovery process periodically to ensure it works as expected. Establish clear protocols for handling data loss and service disruptions to minimize impact.

By addressing these engineering challenges, SaaS startups can build more robust, scalable, and secure applications, ultimately improving their chances of long-term success. This can save much more development time and costs in the longer run. Will keep adding to this.

After years of experience these are the things that I learned the hard way & follow these principles,when working on any project. Take it as a guideline if you are a newbie to programming & professionals may already recognize it's importance.

Get requirements crystal clear!

Clearly define how the end result would look like before starting coding. If possible make a blueprint of it.

First build your MVP

MVP stands for minimum viable product Just focus on making the working prototype and test then start enhancing and adding new features

Don't all the way go for performance!!

First get the application working & then optimize for performance..

Don't rely too much on frameworks

Be well-versed with the language, as frameworks change over time but the core remains the same.

No language is good or bad

Look for which language is appropriate or best suited for your purpose.Don't stick to one all the time.

Keep the base concepts clear

Master the base concepts, which will not only get you for better understanding but also increases your flexibility to adapt new technologies

Know who your target audience is!

Usually large systems have to be opinionated at times, knowing your target audience will help you better understand the requirement, & then go on generalizing as per the needs.

Always a place for growth

If your target audience niche is large enough, if you product is up to the standard and solves the problem you are good to go don't worry too much about the growth of your product

Finally Have fun!!

A quick fix -

For macos devices-

Just add these two css properties.

-webkit-font-smoothing: antialiased;
-moz-osx-font-smoothing: grayscale;

Take a look at the drastric difference this makes on macos devices:

Before -

After -

For Windows-

It's strange that in Windows renders the font much more better using the SVG fonts. So I have the typical font-face snippet that looks something like this.

@font-face {
  font-family: ‘Circular’;
  src: url(‘circular.eot’);
  src: url(‘circular.eot?#iefix’) format(‘embedded-opentype’), url(‘circular.woff’)
      format(‘woff’), url(‘circular.ttf’) format(‘truetype’);
}

Just add the last line for the SVG font -

@font-face {
  font-family: ‘Circular’;
  src: url(‘circular.eot’);
  src: url(‘circular.eot?#iefix’) format(‘embedded-opentype’), url(‘circular.woff’)
      format(‘woff’), url(‘circular.ttf’) format(‘truetype’), url(‘circular.svg#svgFontName’)
      format(‘svg’);
}

Note - SVG fonts are quite heavy in file size, so that’s something to consider. They could go up to 200kb per file. This font type is also not as flexible as others like TTF in terms of changing kerning or line spacing. Finally, the rendering performance of it might be too slow for long body text.

And your work is done!.

Before we start digging deep in the internals just let you know this article will give overview of its working and references are provided for detailed explanation and this post is meant to be technical i.e it is intended for developers and anyone with CS background.

Many research articles exist today on this topics but I feel most of them is too complicated, not straight to the point and well So I decided to write my own.

-> Introduction

-> Working

-> Conclusion

-> References

Introduction

Long story short, Spanner is a NewSQL database that aims to meet all features of Sql databases along with horizontal scalability, consistency and high availability. It's world’s first horizontally-scalable relational database that can be stretched not only across multiple nodes in a single data center but also across multiple geo-distributed data centers, without compromising ACID transactional guarantees.

Working

Before digging deeper it's good to know few things in order to better understand how it is working internally.

Scalability -

Horizontal Scalability (systems that can be scaled as per needs by adding more machines to the network) has never been easier to achieve in relational database systems, it is one main aspects which lead to rise of NoSql databases lately.

As in scalable systems,the first thing comes to mind is sharding (in simple words partitioning the database without compromising it's consistency), which is difficult to implement in relational databases. Spanner does this by itself i.e automatic called load-based sharding which partitions the rows based on some range on basis of appropriately selected primary key.

Availability -

Next big commitment is higher availability, data is replicated synchronously for each storage request, i.e for each storage request first the data is replicated in other machines or datacenters in network (usually 3 to 4) after that further operations are carried on it.

What if a node in a network fail's, will the system crash?. As spanner is a distributed system spanner uses a concencus algorithm called paxos.Those who are not familiar with paxos, for now Paxos is a family of concencus algorithm.At high level of abstraction and for relevence of this article, it will prevent system failures and network from shutting down if any node in the network fails, as another surviving node will take it's place and retain knowledge of the results i.e data is recovered from it's replicated copies. in other words maintains high availability.

For implementing paxos algorithm in real world, requires all the nodes to be able to communicate in real time with as much low latency as possible which requires high performance systems and communication channels. As for the tech giant network performance is not much of an issue, as google lays off it's own fiber optic cables throughout the globe.

What about consistency and serializability ?

Consistency says transcation must change affected data only in allowed ways i.e data written must be valid and should not violate any defined rules or contraints specified in the system design or schema. For simplicity, serializability tells that the sequence of actions performed in real time should reflect the same in the database. For sequencing the transaction, every transaction holds a timestamp, and for this we require a global atomic clock. This clock should have high accurate and precision and is shared across continents. So google has something called truetime i.e servers with atomic clock throughout the world.

What is Truetime ? And how it manages transactions throughout the globe? TrueTime is a highly available, distributed clock that is provided to applications on all Google servers. TrueTime enables applications to generate monotonically increasing timestamps which is also used for external consistency.For now just understand this we will come to this in a bit.

Architecture

Write Operation -

As like most ACID databases, Spanner uses two-phase commit (2PC) and strict two-phase locking to ensure isolation and strong consistency. 2PC has been called the “anti-availability” protocol because all members must be up for it to work.I means in the commit phase,the nodes of that respective paxos group cannot serve other request (ex: read request) at that point of time. Spanner mitigates(makes it less severe) this by having each member itself be a Paxos group. So in that time frame 2PC “member” is available even if some of its Paxos participants are down and take more time. Data is divided into groups for storing and replicating data.

For two phase locking protocol, the TrueTime considers the time for acquiring the lock to be earlier by certain duration which is calculated considering latency for a request (for acquiring lock) to execute,usually in milliseconds. It also predicts the time at at which the lock would be released at it's latest or max, which google calls its as (now + epselon). which will be required for read operation to wait for.

Read Operation-

It's more intresting to know about read operation rather than write operation. What read operation basically does is that it returns the state of database at any given point. So data to be fetched for example, taking two different records located across different data center located in different continent should be the same for current time instance, any one of the copies should not be obsolete(expired) or newly modified or changes with respect to the time frame other wise the consistency of system is compromised.

A Blocking read operation is the option you might say, but it is leads to poor performance. For this,at any given time, spanner takes snapshots of the tables. When a read operation occurs spanner fetches the latest snapshot for that data. Retrieving snapshots spanner requests truetime to give the time at which it can fetch the latest snapshot of data. And if the time to wait in response exceeds a certain threshold limit then it queries the leader node of the paxos group for sending first the latest snapshot of data regardless of the time to wait.

What happens during a Partitioning

In general Spanner chooses C over A when a partition occurs. In practice, this is due to a few specific choices:

• Use of Paxos groups to achieve consensus on an update; if the leader cannot maintain a quorum due to a partition, updates are stalled and the system is not available (by the CAP definition). Eventually a new leader may emerge, but that also requires a majority.

• Use of two-phase commit for cross-group transactions also means that a partition of the members can prevent commits.

The most likely outcome of a partition in practice is that one side has a quorum and will continue on just fine, perhaps after electing some new leaders. Thus the service continues to be available, but users on the minority side have no access. But this is a case where differential availability matters: those users are likely to have other significant problems, such as no connectivity, and are probably also down. This means that multi-region services built on top of Spanner tend to work relatively well even during a partition. It is possible, but less likely, that some groups will not be available at all.

But never the less the tech giant made it's way of accomplishing this first.

References -

1. Spanner docs

2. Google research article

3. Cloud Spanner Introduction

4. Google research article #2

When utilizing a cloud environment, optimizing costs and maximizing resource utilization are crucial considerations. This is particularly important for teams and organizations that rely on Amazon Web Services (AWS) Compute and Relational Database Service (RDS) Instances, as scalability of compute and databases is essential to accommodate growing demands. While options like adding additional servers behind a load balancer or upgrading instance types to larger sizes exist, it's important to note that taking advantage of reserved instances becomes challenging when the flexibility to dynamically change instance types is desired.

EC2 Instance Cost Optimization

AWS offers a variety of instance types within the general category, with the t2.micro series being commonly available for the Free Tier. However, for organizations utilizing general purpose Linux EC2 instances, it is advisable to transition from the t2 series to the t3 series once the free tier or tier hours have been utilized. This switch allows organizations to continue benefiting from cost-effective options while accommodating their computing needs effectively.

The advantages of leveraging the t3 series over the t2 series are evident from the pricing table provided. Not only is the t3 series more cost-effective, but for nano, micro, and small instances, it offers 2 vCPUs instead of just 1 vCPU. Additionally, the t3 series provides faster network performance, making it a superior option in terms of both cost and machine capabilities.

To take advantage of the t3 series, a simple process requiring approximately five minutes of downtime per EC2 instance can be followed. The steps involve stopping the instance, clicking on "change instance type," selecting the equivalent t3 size, and starting the server again. However, it's important to note that if the server doesn't have an Elastic IP address assigned, the Public IP address will change, while the private IP address remains unchanged.

Moreover, for applications that rely on technologies providing binaries for arm processors, setting up a new server with the t4g series is recommended. This transition involves migrating the workload from the t2/t3 to the t4g server. The t4g series offers roughly half the cost of the t3 series while delivering better performance.

According to AWS, PHP performance is 30% better on a t4g instance compared to the t3 series, as per the provided comparison.

What works on t4g arm64 processors?

• Java
• Golang
• PHP
• WordPress
• ERPNext
• Ghost CMS
• Strapi CMS
• GitLab
• GitLab Runner
• MongoDB

On-demand Pricing v/s other cost optimization options

Many users opt for on-demand servers when they are uncertain about the need for a larger server to handle increased loads. In such scenarios, the Compute Savings Plan can be a suitable alternative to reserved instances.

If a project or organization can confidently determine the number of EC2 instances required, choosing the Compute Savings Plan becomes a logical choice. This approach provides flexibility to change EC2 instance types, terminate and create new servers as needed, while benefiting from a price commitment to spend on EC2 instances per hour for Compute Power.

To leverage the Compute Savings Plan, users can calculate the per hour cost of all the instances they require based on the Savings Plan rate and sign up for it through the Billing dashboard in the AWS Console. As illustrated in the table below, Savings Plan prices are nearly 27% cheaper, resulting in significant cost reductions. In simpler terms, by utilizing the Compute Savings Plan, the cost of a fifth server is saved for every four servers deployed.

If a specific series of EC2 instances is being used, let’s say t3, then there’s an option to commit on per hour usage of EC2 instances by series. It’s possible to change instance type within the series, leading to a cost reduction of up to 37%. So, every two servers help cover the cost of a third one.

When calculating the hourly rate of the instances, account for how many hours the servers are kept up. During non-active hours, the non-production servers can be powered down.

EBS Volume Cost Optimization

By default, when creating an EBS Volume in AWS, the volume type is set to gp2. However, it is worth noting that gp3 volumes offer a more cost-effective and faster alternative to gp2 volumes. The new gp3 volumes provide a baseline performance of 3,000 IOPS and 125 MB/s at any volume size.

According to AWS, gp3 volumes deliver SSD-like performance at a 20% lower cost per GB compared to gp2 volumes. Additionally, by decoupling storage performance from capacity, gp3 volumes allow for easy provisioning of higher IOPS and throughput without the need for additional block storage capacity. This improves overall performance while reducing costs.

Changing EBS Volumes from gp2 to gp3 is a straightforward process that does not require any downtime. Simply follow these steps in the AWS Console: go to EC2, navigate to EBS, select the desired EBS Volume, click on "Actions," choose "Modify Volume," and change the Volume type to gp3. AWS will charge a one-time cost for the data copying involved, but in the long run, significant savings can be achieved due to the 20% cheaper pricing and improved performance provided by gp3 volumes.

References

https://aws.amazon.com/ec2/pricing/on-demand/ https://aws.amazon.com/savingsplans/compute-pricing/

Positives

1. Talented co-workers. Above everything else, I want to be surrounded by smart people who will push me to learn, grow exponentially, and progress in my career.
2. Flexible hours and remote work. After a three-month stint working remotely abroad, there's no way I could go back to a typical 9-5 desk job. Ideally, I'll work from home at least one day a week. I think 100% remote work is excellent, but not for everyone.
3. Personal health. Having a culture with a healthy work-life balance that doesn't promote burnout is critical. A culture focused around personal health that has adequate health coverage as well as some sort of gym package (on-site or stipend).
4. Autonomy. Does your manager give you the freedom to make decisions in your area of expertise? Do they trust and value your opinion? Do they go to battle for you? Do they set clear expectations?
5. Working with industry standards. Are the main programming languages widely used? Does the company value open-source software? How much internal software is being used? From my experience working with languages that were not industry standard, it can be a nightmare just trying to find a simple answer on Google. If you happen to encounter a bug, you might not have the community support needed to get it patched and released in a timely manner.
6. Office location and environment. Transitioning from my last job to my current role, I cut my commute in half saving ~40 minutes a day. That time really adds up and you can put a price to it. Ideally, the office has lots of natural light and proper space for everyone (not four people crammed at one desk). I honestly don't mind open office plans that much if you have the flexibility to work remotely.
7. A culture of open communication. Are there frequent meetings with your boss (and bosses)? Is the feedback loop short? Are meetings that don't provide value reduced to an email? Are developers given large, open blocks of time to focus on coding? Does executive management seek feedback and continuously improve their processes?

Don't Care

My list for what I don't care about is much shorter. I'm not too jaded (...yet).

1. Game rooms. I mean, I get it. I see the appeal and why it's pushed as a recruiting tool. But in practice, I've never wanted a ping-pong break in between coding sessions. Some people treat it as "culture building" but in my opinion, if you satisfy the above criteria for benefits, then you already have a pretty amazing culture. I'd rather build comradery with my teammates over a great lunch than darts.
2. Dog-friendly / kid friendly. Let's be honest - most of the time someone brings their new puppy to work they are distracting everyone. I don't think I really need to elaborate more on a child. I see the benefit, and hey maybe your kid/dog is well behaved and can handle it, but it's not for me.

Ultimately, it comes down to the culture the company wants to promote. If their pitch to me is "We have beer on tap and a game room!"... that's going to be a hard pass. A better way to pique my interest would be something like this:

"You'll work with industry leaders in your area and you'll have the flexibility to work remotely whenever necessary."

2020 we are looking a huge trend in client-side rendering technologies. But arguably server-side frameworks are here to stay for a long long time. So which one should you use from. This was the year where I tried looking into all these frameworks which i previously used which I'm gonna talk about and give my take on that.

Highlights

• Approach as per different requirements.
• 🚀Listing mainstream serverside technologies used.
• 📚Selection based on scenerio.
• 📈Industry trends
• 🎤My opinion and views.

Most the frameworks I'm gonna talk is about MVC frameworks. Bit cliche but go with technologies that your team is already famaliar with if it works fine.

The frameworks are

• Java Spring
• Django
• Laravel
• Ruby on Rails

Until and unless you want to have really high performant application with fluid client side applications you are good to go with traditional front-end stack like HTML, CSS and JS rather than jumpung on React/Vue/Angular.

Next thing is to assess the performance and scalability requirements for the product. For majority of case all frameworks would do the job. But when it comes to performance it comes down to language benchmarks in terms of execution speeds. For high-performance api java spring and some might say golang frameworks, this is required when you say 20000 requests/second, for example a trading platform.

Majority of times this won't be the case, so all other frameworks would work just fine.

Nowadays, we see a equiliberium between front-end and backed frameworks working together to get good of both worlds. So now we are predominantly witnessing the combination of both client-side, rendering and server-side rendering frameworks like Next.js for React and Nuxt.js for Vue js.

Choose based on given scenerio (Sequence matters!) -

Mocking or prototyping API Use Json Server from typicode. Get a full fake REST API with zero coding in less than 30 seconds (seriously) for free.

If the project is really really small and less complex logic. And you are making a API and does not require security and authentication.

-> Go with micro-frameworks like Flask (Python), Lumen(PHP) or simple golang(if famaliar) etc and many more as they are lightweight and does the job well.

Let's say your project is fairly big. Building API that may include authentication or other utilities for [rapid development] [descent performance]

-> Laravel, Rails, Django.

Let's say your project is fairly big. Building API that may include authentication or other utilities for [rapid development], [descent performance] [convention] [maintainable] [readable]

-> Rails, Laravel, Django[more verbose].

Your app is more focused on data visualization and machine learning stuff

-> Django, Java Spring (Spring-boot).

Let's say your project is fairly big and higly performant.[Highly performant] [Highly Scalable] [Stable]

-> Java Spring (Spring-boot), Golang.

Industry Standard

Most corporates use Java as the language has many rich feature built in like strong Object-oriented concepts, strongly typed, highly performant, scalablea and robust JVM etc. Startups are more likely to use Rails and Django or laravel for their rapid development needs. For those who know C and C++ mainly in application with huge scale use it like FANG companies.

Conclusion

If you do not know how much traffic you are dealing with on initial scale go with rapid development tools & frameworks to put into production as soon as possible and then switch to high performant frameworks if your application grows to handle big data and traffic. If you expect the application to process more requests go with java or golang, prefer java due to huge community, maturity and stability. Also can start using java's spring boot for rapid development as well.

So what do you think? What's your take on it? Which would you prefer. Lets discuss it on slack.

It's 2021, pics are louder than words..

Here are couple of images that might give you some highlights. I'm now thinking to gather all content and design a seperate page for it.

Quick Tips

If you're planning to head to Dubai, here's a few things you should know (plus some general travel tips):

• Keep tabs on flights and track prices.
• Ideally, book your lodging months in advance for the best rates.
• Ensure your credit card doesn't have international fees.
• I would recommend taking out some us dollars ahead of time or at the airport and then convert it into dihram (currency of dubai). There will be places that don't accept a credit card.
• If you use Spotify, consider downloading some playlists offline as well.
• Check into your flight as early as possible!
• Visting in winters would be a good choice as it is to hot in summers.

To be updated soon!