High Scalability

This is something that can be difficult to learn even if you've been working in the industry (lord knows we've all seen awful practices at various companies in our career).

This is probably not popular advice, but of all the places I've worked, Google seemed to have the highest standards for best practices I've seen. I recommend paying attention to Google's best practices, in their blogs, certification programs (like the google cloud developer cert), Coursera courses, product docs, codelabs, style guides, git code, etc. Obviously everything they do won't be a right fit for your company, but it's something to aim for.

Enforce code style (be specific and use a linter), and write tests as you go. Try to keep bad code out of your repo before PRs can even be merged. I use Jenkins and git hooks to enforce this for the whole team.

Draw up design docs and understand business needs before diving into projects and features.

Understanding good architecture and operational principles will make you much more valuable as a developer than your peers. Read the Google SRE book, it's free. Also read http://highscalability.com/ articles and learn from other companies' triumphs and mistakes.

Books about architecture include the micro services book by Sam Newman. You may not ultimately be responsible for making these decisions, but demonstrate your value by being able to understand and provide quality feedback to your tech leads and architects.

Study and learn about project management…

Designing for fault tolerance and scaling out instead of individual node durability and scaling up is, in most cases, a sounder approach. Since the vast majority of applications map well to this case, it makes sense for Amazon to focus on features that assume/assist scale-out.

It's easier to design for scale-out than one might think; a great resource to get started is http://highscalability.com.

Regarding EBS, I haven't seen the hangup issue you've described. Any data?

As for low inter-node latencies, Amazon has an offering that specifically addresses that need:
http://aws.amazon.com/ec2/hpc-applications/

Overall, I think Amazon is making a lot of inroads in areas with specific hardware demands. They just launched GPU compute options, and I expect we'll even see SSDs soon.

Read "Functional Programming in Scala" or any other good book on functional programming to see things differently if you've just stuck with imperative so far. There's also http://iloveponies.github.io/120-hour-epic-sax-marathon/

Read books on concurrency ("Learning Concurrent Programming in Scala" if you carry on with scala) and then you'll find different ways to write performant concurrent code - for CRUD sites or other stuff.

I'm not pushing scala rather exposure to other ways of doing things you might not have come across - functional programming, futures, akka, etc.

But yeah, also design patterns. And have you read http://highscalability.com/ for architecture ideas?

There are various flavors of cloud. For example Google cloud is mostly app or app based cloud, while AWS is bare metal cloud.

I would suggest following this blog - http://highscalability.com

which goes into real life architecture of various services and gives behind-the-scene look into cloud and non-cloud architecture, and why they chose to use certain tools or technologies.

Core concepts in domains like virtualization, networking, authentication, scalability are the same whether you do it in your own data center or cloud.

My advice is to strengthen yourself in core concepts.

HN is a great resource with plenty of important news posted, along with the HighScalability blog [1] and SoftwareEngineeringDaily podcast [2].

1. http://highscalability.com/

2. https://softwareengineeringdaily.com/

Other than that, reading the blogs of the various vendors is how I keep up (using Feedly with RSS). The modern projects are Redshift, BigQuery, Snowflake, Azure DW, MemSQL, Clickhouse, YellowBrick with older projects being Vertica, Teradata, Greenplum. It's also useful to follow the "new" distributed SQL projects like CockroachDB, Citus, TiDB, Vitess, Yugabyte.

Here is one,

http://highscalability.com/

I bookmarked an AskSlashdot thread on a similar topic a while ago but Slashdot has archived the original thread so here is the google cache entry, look at the O'Reilly books they should answer a lot of your questions.

http://64.233.169.104/search?q=cache:eugOZQ5ltGwJ:ask.slashdot.org/article.pl%3Fsid%3D07/08/23/1447220+Learning+high-availability+server+side+development+site:slashdot.org&hl=en&ct=clnk&cd=1&gl=us

A final word of caution though, There is no silver bullet. You are your applications best scalability expert.